Ableton Studio MCP
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., "@Ableton Studio MCP program a 16-bar techno drum groove in my Ableton set"
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.
Ableton Studio MCP
The Ableton Live MCP server that lets Claude (or any MCP client) compose, arrange, mix, master, listen to and analyse music in Ableton Live 11 & 12.
By Olivier Cedrati (@cedrati).
Quickstart · Features · Tools · FAQ · Roadmap · Changelog · Issues
About
AI music production in Ableton Live. This is a Model Context Protocol (MCP) server and Ableton Remote Script that connect Ableton Live to Claude, Claude Code, Claude Desktop, Cursor and other MCP clients, so an AI assistant can work inside your Live set: write MIDI, program drums, build arrangements, mix with Live's devices, check loudness (LUFS) and true peak, and reason about harmony.
Ableton Studio MCP, written and maintained by Olivier Cedrati, is a full production assistant. Beyond writing notes, the assistant can mix (faders, sends, return and main-track effects, routing), listen to the result and judge it like a mastering engineer (LUFS, true peak, tonal balance, stereo, a spectrogram it can look at), and compose with real music-theory knowledge (scales and modes, style sheets, key and chord analysis, clip transformations, voice-led progressions).
It is developed on the feat/mixer-scenes branch of cedrati/ableton-studio-mcp. It is published on PyPI as ableton-studio-mcp. (The ableton-mcp package on PyPI is the original project and does not include any of this.)
No data is collected: no telemetry, no analytics, nothing sent anywhere (see Privacy).
Related MCP server: AbletonMCP
Features
Area | What the assistant can do |
Mixing | Volume, pan, sends, mute, solo, arm on tracks, return tracks and the main track. Load effects on return tracks and the main track (a shared reverb, a limiter). Read every parameter as Live displays it ( |
Routing | Set track inputs, outputs and monitoring: layer one MIDI part on several instruments, resample the main output, route to a return. |
Listening & mastering analysis | Record the main output in real time and get a report: loudness per ITU-R BS.1770 / EBU R128 (integrated, short-term, momentary, loudness range), true peak, PLR, tonal balance against a reference curve, resonances, stereo width per band, low-end mono, each track's meter level, a spectrogram image — and ranked findings with fixes for a delivery target (streaming, club, classical, broadcast, podcast). |
Drums | Program a Drum Rack from 19 electronic patterns (techno, house, garage, breaks, d'n'b...) or your own step grids: pads found by name, Euclidean and polyrhythmic layers, ratchets, ghost notes, per-note probability, fills, swing, Live's Groove Pool. |
Long-form evolution & arrangement | Curves over 16–64 bars (filter builds, reverb swells, slow LFOs, phrase steps) on extended clips; whole Arrangements built from Session clips by section (DJ-friendly techno, compact 64 bars, minimal, house) with locators — the clip envelopes play as track automation. |
Music theory | ~50 scales and modes with their character and typical styles; 24 style sheets (baroque to techno); key, mode and chord analysis of a clip with roman numerals; 17 clip transformations (mode change, diatonic transposition, harmonization, arpeggios, voicings, swing...); voice-led chord progressions; Live 12's song scale. |
Clips | Notes in Arrangement clips, partial note removal, loop brace and markers, warp (modes, markers, conform a loop to the tempo), clip automation envelopes. |
Files | Import Standard MIDI Files into clips; analyse any WAV/AIFF. |
Session | Duplicate and delete tracks; list, create, rename, duplicate, launch and delete scenes; delete Arrangement clips. |
Devices & browser | Know every device in the set and what it does (native devices from the Live 12 manual, Max for Live, plug-in families) and every installed plug-in; route a Compressor's sidechain; plug-in presets; Simpler sample loading and slicing; rack variations; drum choke groups. Plugins (VST, VST3, AU), User Library and Packs load like built-in devices. |
Reliability | Playhead moves, locator creation and device loading reply only once Live has applied them; version handshake between server and Remote Script; capability checks so a newer server never sends a command an older script would misread. |
Everything is covered by automated tests (324) and checked end to end in Ableton Live 12. See the Changelog for the details of each release.
Quickstart
Requirements
Ableton Live 11 or 12 (Live 12 for the song scale; Live 10 works for the original features)
uv — on macOS:
brew install uvAn MCP client: Claude Code, Claude Desktop, Cursor...
Python (3.10+) and the dependencies, including numpy, are installed automatically by uv.
1. Add the server to your MCP client
claude mcp add ableton -s user -- uvx ableton-studio-mcp{
"mcpServers": {
"AbletonStudioMCP": {
"command": "uvx",
"args": ["ableton-studio-mcp"]
}
}
}uvx ableton-studio-mcpRun the server in one client at a time.
2. Install the Remote Script into Live
uvx ableton-studio-mcp installThis copies the AbletonStudioMCP control surface into your User Library's Remote Scripts folder, found from Live's own settings (--list-targets shows where it would go, --target <folder> forces a location, --dry-run changes nothing).
Coming from 1.x? The control surface was called AbletonMCP before 2.0. Deselect it in Live and run uvx ableton-studio-mcp install --remove-legacy to delete the old folder: both listen on the same port.
The server and the Remote Script must come from the same version — always install both from this repository.
3. Enable it in Live
Start (or restart) Ableton Live.
Settings → Link, Tempo & MIDI → Control Surface: choose AbletonStudioMCP, with Input and Output set to None.
4. Check
Run the built-in check, which looks at Python, uv, the script installed in your User Library, the Control Surface setting and the script actually running in Live, and says what to fix:
uvx ableton-studio-mcp doctorOr ask the assistant to run get_remote_script_info: it should report script_version 2.1.x and up_to_date: true.
Updating
Fetch the new version and install its Remote Script:
uvx --refresh ableton-studio-mcp installRestart Live — re-selecting the control surface does not reload the code.
Restart your MCP client. If it still runs old code:
uv cache clean ableton-studio-mcp(with the client closed).uvx ableton-studio-mcp doctorconfirms that everything matches.
To try unreleased changes, use the development branch instead of PyPI: replace ableton-studio-mcp with --from git+https://github.com/cedrati/ableton-studio-mcp@feat/mixer-scenes ableton-studio-mcp in the commands above.
What you can ask
Compose and arrange
"Write a C minor organ fugue: subject, answer at the fifth, countersubject, stretto."
"Give me a deep house progression in A minor with offbeat stabs, then a rolling bassline."
"Analyse the clip on track 2: key, chords, roman numerals."
"Re-harmonise this melody in Dorian, add a third above, swing it at 58 %."
"Import this MIDI file and transpose it to F#."
"Program 8 bars of rolling techno on the 909 kit, with a 5-in-16 percussion layer and a clap roll every 4 bars."
"Open the acid bass filter over 16 bars, then lay out a 64-bar techno arrangement with a DJ intro and outro."
Mix and master
"Listen to the whole track and tell me if it's ready for streaming."
"What's loaded in this set, and which of my plug-ins would make a better acid line?"
"Duck the bass with the kick."
"Put a cathedral reverb on return A and send the pads to it."
"The low end is muddy — find out why and fix it."
"Layer the bass MIDI on a second synth one octave down."
Tool reference
Indexes start at 0. Times and lengths are in beats. Notes use MIDI numbers (60 = C4 in scientific pitch, shown as C3 in Live).
Session and transport
Tool | Description |
| Tempo, time signature, tracks, transport; full state dump. |
| Transport. |
| Scenes. |
| Arrangement view, playhead, locators (create, rename, delete by name or position). |
| Live's Undo and Redo. Each tool call that changes the set is one step, and tools that make many changes at once (drum patterns, progressions, arrangements, MIDI imports…) are one step too. |
| Make a whole request one undo step (closed automatically after two minutes if left open). |
| Version handshake and capabilities. |
Tracks, mixer and routing
Tool | Description |
| Tracks. |
| Track, return track ( |
| Mixer; reply with Live's display value ( |
| Input/output type and channel, monitoring ( |
| Live's output meter of every track, return and the main track. |
Devices and browser
Tool | Description |
| Browse |
| Load by browser URI, on a track, a return track or the main track. |
| Every parameter with its range, Live's display string and, for list parameters, the names of the values. |
| Every device in the set and what it is for; optionally every installed plug-in by vendor. |
| Sheet for a native device (Live 12 manual), a bundled Max for Live device or a known plug-in; the native catalogue. |
| Real device name, kind, latency, and device-specific state: sidechain, plug-in presets, Simpler, rack. |
| Route a Compressor's sidechain from another track and switch it on (ducking). |
| List or select a plug-in's presets (as exposed to Live). |
| Load a sample into Simpler; classic / one-shot / slicing by transient, beat, region; warp, crop, reverse. |
| Rack macro variations (list, recall, store, randomize); Drum Rack choke groups. |
Clips and notes
Tool | Description |
| Session clips. |
| Notes, in Session or Arrangement clips ( |
| Loop switch, loop brace, start/end markers. |
| Warp mode, markers, pitch, gain; |
| Clip envelopes for device and mixer parameters (Session clips). |
| Arrangement clips. |
| Import a |
Listening and analysis
Tool | Description |
| Records the main output between two song positions on a temporary track (in real time), samples every track's meter, then returns the mix report and the spectrogram image. The track and the recorded file are deleted afterwards, so listening never fills the project with audio ( |
| The same mastering report for any WAV/AIFF file. |
| Lightweight level report (no |
| Record armed tracks into the Arrangement between two positions; find the recorded file. |
The mix report checks: integrated / short-term / momentary loudness and loudness range (validated on EBU reference signals), true peak (4× oversampled), PLR and crest factor, long-term spectrum and its tilt against a −4.5 dB/octave reference (sub, lows, low-mids, mids, high-mids, highs, air), narrow peaks with their note names, stereo correlation and width per band, low-end mono, DC offset. Each finding comes with a severity and a concrete fix using Live's own devices.
Drums and groove
Tool | Description |
| Pattern library (techno four, rolling, hypnotic, minimal, dub, hard, acid, Detroit, house, deep house, tech house, afro house, UK garage, breakbeat, electro, drum & bass, dubstep, trap, EBM) with tempo, swing and production notes; Euclidean rhythms. |
| A track's Drum Rack pads and the role each plays (kick, clap, hats, perc...). |
| Program a clip from a style and/or grids per role: |
| Live's Groove Pool: list grooves, apply one to a clip, adjust amounts and the global Groove amount. |
Evolution and arrangement
Tool | Description |
| Extend a MIDI loop to N bars and write long curves per lane (device parameter or volume/pan/send): linear, exp build-up, log, S-curve, swell, slow sine/triangle, steps, random walk. |
| Lay out the Arrangement from Session clips by section (template or custom), roles from track names, per-section clip variants, tiling, locators, |
| Map of which track plays in each block of bars. |
| Templates ( |
Music theory and composition
Tool | Description |
| ~50 scales and modes — church modes, harmonic/melodic minor families, pentatonics, blues, bebop, symmetric, Japanese, gamelan, flamenco — with character, characteristic note, styles; or one scale in a key: spelled notes, diatonic chords with roman numerals and functions, relative modes, Live's name. |
| 24 style sheets (baroque, classical, jazz, bossa nova, blues, gospel/neo-soul, funk, pop, rock, house, techno, trance, drum & bass, boom bap, lo-fi, trap, R&B, reggae, reggaeton, afrobeat, flamenco, film score, ambient, synthwave): tempo, metre, scales, harmony, progressions, groove and swing, bass, melody, arrangement, Live devices. |
| Reharmonisation ideas for a chord, with the reason for each. |
| Key and mode, chords with roman numerals ( |
| Chain of operations, in place or into an empty slot: |
| Roman numerals (secondary dominants, borrowed chords, Neapolitan) or a style's progression, voice-led, played with an accompaniment pattern and a bass line. |
| Live 12's song scale and Scale Mode. |
Good to know
Live's API has limits. A script cannot save the set, export audio, create group tracks, or write Arrangement automation directly (tempo changes included). Track automation still reaches the Arrangement through Session clip envelopes, which
build_arrangementplaces for you. Live's own analysers (Spectrum, EQ Eight's display, Max for Live meters) don't expose their readings — which is why listening works by recording the main output.Listening takes real time: analysing a 3-minute song means playing it for 3 minutes.
Device loading, playhead moves and locators reply only once Live has applied them. Loading the same device that is already on a track resets it in place (the reply says so).
Undo works step by step. Live on its own merges everything a script changes into one undo step, so one Cmd+Z would wipe out a whole session of edits; Ableton Studio MCP gives each change its own step, and ask the assistant to
undoto take back exactly its last action. Destructive tools (delete_track,delete_scene,delete_clip,delete_arrangement_clip) can be undone the same way, but saving your set before big experiments is still wise.
FAQ
Does Ableton Studio MCP collect any data? No. There is no telemetry, no analytics and no data collection of any kind, and the server makes no internet connection: everything stays between your MCP client and Live on your computer. See Privacy.
How do I control Ableton Live with Claude? Install this MCP server in Claude Code, Claude Desktop or Cursor, install the Remote Script into Live, and select AbletonStudioMCP as a control surface (see Quickstart). Then ask in plain language: "program 8 bars of rolling techno on the 909 kit".
Can an AI mix and master in Ableton Live?
It can measure and act: listen_to_arrangement records the main output and reports integrated loudness (LUFS, EBU R128), true peak, loudness range, tonal balance, resonances and stereo width against a target (streaming −14 LUFS, club, classical, broadcast, podcast), with a spectrogram image the assistant looks at; the mixer, EQ Eight, Limiter, Compressor sidechain and other devices are then adjusted through the API.
Does it work with Ableton Live 12, Live 11, Push, Max for Live? Live 11 and 12 (Live 12 for the song scale and some device features). Max for Live devices and VST/AU plug-ins load like built-in devices; Push and other control surfaces keep working alongside it.
Which MCP clients are supported? Any MCP client: Claude Code, Claude Desktop, Cursor, and others that speak the Model Context Protocol.
Can it make techno and electronic music? Yes — drum programming from 19 electronic styles or step grids (Euclidean rhythms, ratchets, per-note probability), long filter builds over 64 bars, DJ-friendly arrangements with intro and outro, sidechain ducking, and a club loudness target.
What's next? The roadmap lists the planned work: sound design recipes, A/B comparison with reference tracks, finding samples by sound, audio-to-MIDI transcription, and more. Ideas and contributions are welcome in the issues.
What can't it do? Live's API doesn't let a script save the set, export audio, create group tracks, write Arrangement automation directly or use Live 12's MIDI Tools; see Good to know.
Troubleshooting
Start with ableton-studio-mcp doctor (see Check): it diagnoses most of the cases below.
Problem | Fix |
| The script in Live is older than the server. Re-run the install command, then restart Live. |
The server still runs old code after an update | Restart the MCP client; if needed |
No connection | Check that AbletonStudioMCP is selected as a Control Surface and that only one MCP client runs the server. |
Timeouts on big requests | Ask for the work in smaller steps. |
How it works
MCP client (Claude…) ⇄ MCP server (ableton_studio_mcp/, Python) ⇄ TCP 127.0.0.1:9877 ⇄ AbletonStudioMCP control surface inside Live (ableton_studio_mcp/live_script/)The control surface runs inside Live and executes commands through Live's Python API. It listens on localhost only (set
ABLETON_MCP_HOSTdeliberately to change that).The MCP server exposes the tools and does the heavy work outside Live: audio analysis, MIDI files, music theory. Its code is organised as:
Module
Role
live.pyThe connection to Live: one socket, reopened when Live restarts, one request at a time, per-command timeouts, and the control surface's version and command list checked on every connection.
app.pyThe MCP application and the
@tooldecorator: checks the commands a tool needs and turns any failure into one readable line.tools/The tools, one module per domain: session, tracks, clips, devices, browser, routing, listening, midi, theory, drums, evolution.
audio_analysis.py,mix_analysis.py,music_theory.py,drums.py,arrangement.py…The domain logic, independent of Live and fully unit-tested.
install.py,doctor.py,server.pyInstaller, diagnostics, command-line entry point.
live_script/AbletonStudioMCP/The control surface that runs inside Live:
transport.py(socket, newline-delimited JSON),registry.py(the command table: each handler's signature is its contract, and the advertised capabilities are generated from it),surface.py(everything runs on Live's main thread fromupdate_display: no threads, non-blocking sockets; reads of a sequence answered in the same pass in under 1 ms, each change given its own display update),undo.py(one undo step per assistant action, even across device loads), and one module per domain (session, tracks, clips, notes, warp, automation, devices, groove, browser, recording, snapshot). It runs in Live's own Python (3.7 in Live 11), so it avoids newer syntax.Messages are one JSON object per line:
{"type": ..., "params": ...}→{"status": ..., "result" | "message": ...}(protocol 2; the server still understands 1.x control surfaces, which send no newline).
Development
git clone -b feat/mixer-scenes https://github.com/cedrati/ableton-studio-mcp
cd ableton-studio-mcp
uv run --with pytest pytest -q # 324 tests, no Live needed
uv run ableton-studio-mcp install # install your working copy into Live
uv run ableton-studio-mcp doctor # check the whole chainThe Live control surface lives in ableton_studio_mcp/live_script/AbletonStudioMCP/ and is shipped inside the package. Versions: __version__ (ableton_studio_mcp/__init__.py), version in pyproject.toml and in server.json are the release number; the control surface's SCRIPT_VERSION only has to be in the same series (major.minor). A release that changes the control surface starts a new series (2.1.0), so users know to reinstall it; a patch release of the server alone (2.0.1) doesn't touch Live. The tests and the release workflow check all of this. Add an entry to the Changelog. GitHub Actions runs the tests on Python 3.10, 3.12 and 3.13 on every push and pull request.
Releasing: push a tag vX.Y.Z matching that version. The release workflow checks the versions, runs the tests, builds the package, publishes it to PyPI (trusted publishing, no token stored), creates the GitHub release and publishes server.json to the official MCP Registry as io.github.cedrati/ableton-studio-mcp (GitHub OIDC; the mcp-name: comment at the top of this README proves the PyPI package is ours).
Privacy
No data is collected. None. Ableton Studio MCP has no telemetry, no analytics, no usage statistics, no crash reporting and no account.
Nothing leaves your computer. The server only talks to Ableton Live on your own machine (127.0.0.1) and makes no internet connection.
Your music, your Live sets and your prompts stay with you. Tools do not receive your prompts, and nothing about your sessions is recorded or sent.
No tracking in Live. The Remote Script only answers the commands it is sent; it does not watch or log what you do.
The telemetry and research-dataset recording inherited from the original ableton-mcp were removed from the code entirely in 1.17.0, along with their online-database dependency (Supabase). Nothing is merely switched off: the code is gone.
The only files the tools write are on your machine (recordings you ask for, temporary spectrogram images, the Remote Script itself): the full list is in TERMS.md.
Credits and license
Author: Olivier Cedrati (@cedrati). Report issues on cedrati/ableton-studio-mcp.
Thanks: Ableton Studio MCP began as a fork of ableton-mcp by Siddharth Ahuja, which first connected Live to AI assistants through MCP. Since 2.0 it is an independent codebase, rewritten from the ground up (versions 1.x remain available under their original license).
MIT License — Copyright (c) 2026 Olivier Cedrati. See LICENSE. This is a third-party integration, not made or endorsed by Ableton.
Available Tools
96 toolsadd_notes_to_clipA
Add notes to a clip; existing notes stay. To replace notes, clear the clip (clear_notes_from_clip) or a range (remove_notes) first.
Parameters:
track_index: The track
clip_index: Session slot, or position in get_arrangement_clips
notes: [{"pitch": 60, "start_time": 0.0, "duration": 1.0, "velocity": 100, "mute": false}, ...] with start_time in beats from the clip start
location: "session" (default) or "arrangement"
Inputs: notes (required), clip_index (required), track_index (required), location. Returns: result
analyze_audio_fileA
Measure a WAV or AIFF file: peak and RMS levels (dBFS), clipping, crest factor, loudness over time (one value per segment), leading/trailing silence, stereo correlation and a coarse spectral balance (low < 250 Hz, mid, high > 4 kHz), with warnings. Use it to check a mix or a recorded take.
Parameters:
file_path: Absolute path of the audio file
segment_seconds: Length of each loudness segment (default 1 s)
Inputs: file_path (required), segment_seconds. Returns: result
analyze_clip_musicA
Musical analysis of a MIDI clip: key and mode candidates (with coverage and outside notes; relative modes are told apart by the harmony, e.g. a V7 pointing to its tonic), chords per segment with roman numerals, out-of-scale notes, range, rhythm (density, offbeat share, polyphony) and melodic motion of the top line. Also reports Live's song scale.
Parameters:
track_index / clip_index: The clip (Session slot or Arrangement index)
location: "session" (default) or "arrangement"
segment_beats: Chord detection window (2 = two chords per bar by default, 4 = one per bar, 1 per beat); identical neighbours are merged
key_root / key_scale: Force the key used for roman numerals (optional)
vocabulary: "basic" (triads and sevenths: classical, pop, counterpoint) or "jazz" (adds 6, 9, sus and extended chords)
Inputs: clip_index (required), track_index (required), key_root, location, +3 more. Returns: result
analyze_mixA
Mastering-engineer report on a WAV/AIFF mix: loudness per ITU-R BS.1770 / EBU R128 (integrated, short-term and momentary max, loudness range), true peak (4x oversampled), PLR, crest factor, long-term 1/3-octave spectrum with tilt and per-region deviation from a balanced -4.5 dB/oct reference (mud, harshness, sibilance, air, sub), narrow resonances (with note names), stereo correlation and width overall and per band (low-end mono), DC. Returns findings ranked problème / attention / ok with concrete fixes against the delivery target, plus a spectrogram image (log frequency, with the short-term loudness curve) to look at.
Parameters:
file_path: Absolute path of the audio file
target: "streaming" (default, -14 LUFS), "club", "classical", "broadcast" (EBU -23 LUFS) or "podcast"
spectrogram: Also return the spectrogram image (default True)
Inputs: file_path (required), target, spectrogram.
arrangement_overviewB
A map of the Arrangement: for every track, one character per block of
block_bars bars ('#' = a clip plays, '.' = silent), so the structure,
the entries and exits of each element and the phrasing are visible at a
glance.
Parameters:
block_bars: Bars per character (default 8)
Inputs: block_bars. Returns: result
arrangement_templatesA
Arrangement templates for electronic music and the automation curve
shapes. Without template: the list (techno_dj, techno_64, minimal,
house) and the shapes. With it: its sections (name, bars, energy 0-1,
roles that play, production tip).
Parameters:
template: Template name (optional)
Inputs: template. Returns: result
build_arrangementA
Build the Arrangement from Session clips, section by section, like a producer laying out a track: each section plays the clips of the tracks whose role is active there, tiled to fill it, with a named locator at its start. Clip envelopes (see write_clip_evolution) come along as track automation, so a filter build or a reverb swell plays in the Arrangement.
Use a template (techno_dj, techno_64, minimal, house; see
arrangement_templates) or your own sections: [{"name", "bars",
"roles": [...]} or {"name", "bars", "play": {"track_index": slot}}].
Track roles come from track names (kick, drums, hats, perc, rumble, bass,
chords, pad, lead, vocal, fx) unless track_roles {"track_index": role}
overrides them. section_slots {"Section name": {"track_index": slot}}
picks another clip for a section (e.g. the automated build variant).
Run with dry_run=true first to see the plan.
Parameters:
template / sections: Structure to build
track_roles: Role per track index, overriding names
start_bar: Arrangement bar to start at (0 = beginning)
default_slot: Session slot used by default for every track
section_slots: Per-section slot overrides
locators: Add a locator at each section (transport must be stopped)
dry_run: Only return the plan
Inputs: dry_run, locators, sections, template, +4 more. Returns: result
clear_notes_from_clipA
Remove every note from a clip. Together with get_clip_notes and add_notes_to_clip this gives read → edit → write: read the notes, change the list, clear the clip, add the new list. For part of a clip use remove_notes.
Parameters:
track_index: The track
clip_index: Session slot, or position in get_arrangement_clips
location: "session" (default) or "arrangement"
Inputs: clip_index (required), track_index (required), location. Returns: result
create_audio_clipA
Put an audio file into an empty Session slot of an audio track (Live 12.0.5 or newer).
Parameters:
track_index: An audio track
clip_index: The Session slot (must be empty)
path: Absolute path of the file (.wav, .aif, .mp3...)
Inputs: path (required), clip_index (required), track_index (required). Returns: result
create_audio_trackC
Add an audio track (for samples, stems, recordings).
Parameters:
index: Where to insert it (-1 = after the last track)
Inputs: index. Returns: result
create_clipA
Make an empty MIDI clip in a Session slot (the slot must be empty).
Parameters:
track_index: A MIDI track
clip_index: The Session slot (scene row)
length: Clip length in beats (default 4 = one bar in 4/4)
Inputs: clip_index (required), track_index (required), length. Returns: result
create_locatorA
Put a named locator in the Arrangement. A locator already at that beat is renamed rather than removed. Playback must be stopped.
Parameters:
name: Label shown in Live ("Intro", "Drop", "Break"...)
time: Song position in beats
Inputs: name (required), time (required). Returns: result
create_midi_trackB
Add a MIDI track (for instruments and drum racks).
Parameters:
index: Where to insert it (-1 = after the last track)
Inputs: index. Returns: result
create_sceneB
Add an empty scene.
Parameters:
index: Where to insert it (-1 = after the last scene)
Inputs: index. Returns: result
delete_arrangement_clipA
Remove a clip from the Arrangement. Later clips on the track move down one index.
Parameters:
track_index: The track
clip_index: Position of the clip in get_arrangement_clips
Inputs: clip_index (required), track_index (required). Returns: result
delete_clipC
Empty a Session slot (create_clip refuses occupied slots).
Parameters:
track_index: The track
clip_index: The Session slot to empty
Inputs: clip_index (required), track_index (required). Returns: result
delete_locatorA
Remove a locator, found by position (exact) or by name. When several locators share the name nothing is removed and their positions are listed. Playback must be stopped.
Parameters:
name: Label of the locator
time: Its song position in beats (wins over name)
Inputs: name, time. Returns: result
delete_sceneB
Remove a scene together with every clip in its row. Ask the user first.
Parameters:
scene_index: The scene to remove
Inputs: scene_index (required). Returns: result
delete_trackA
Remove a track and everything on it. Ask the user first. Tracks after it move up one index.
Parameters:
track_index: The track to remove
Inputs: track_index (required). Returns: result
device_inventoryA
Everything loaded in the set — every device on every track, return track and the main track, racks with their chains — with what each one is and what it is for (native devices from the Live 12 manual, Max for Live devices, known plug-in families such as Arturia emulations), plus, with installed_plugins=true, the VST/VST3/AU plug-ins installed, by vendor.
Parameters:
installed_plugins: Also list the installed plug-ins
Inputs: installed_plugins. Returns: result
device_knowledgeB
What a device does: a native Live device (from the Live 12 manual: kind,
category, purpose, key parameters, electronic/techno uses, sidechain,
tip), a bundled Max for Live device, or a known plug-in (e.g. "Acid V",
"Comp FET-76", "Cthulhu"). Without name, the catalogue of native
devices, optionally filtered by kind (instrument, audio_effect,
midi_effect, max_for_live). Also says what Live 12's MIDI Tools are and
that the API can't drive them.
Parameters:
name: Device or plug-in name
kind: Filter for the catalogue
Inputs: kind, name. Returns: result
drum_patternsA
Drum pattern library for electronic music. Without arguments, lists the
styles (techno_four, techno_rolling, techno_hypnotic, minimal_techno,
dub_techno, hard_techno, acid_techno, detroit_techno, house_classic,
deep_house, tech_house, afro_house, uk_garage, breakbeat, electro,
drum_and_bass, dubstep, trap, ebm). With style, its grids per role,
tempo, swing, production notes and the available fills. With
euclid_hits, returns a Euclidean rhythm grid, e.g. 3/8 = tresillo.
Grid language (one string per role, 16 steps = one bar of 16ths): x hit · X accent · o ghost · . rest · 2 3 4 ratchet · ? 50 % chance · * 25 % chance ghost.
Parameters:
style: Pattern style (optional)
euclid_hits / euclid_steps / euclid_rotate: Euclidean rhythm (optional)
Inputs: style, euclid_hits, euclid_steps, euclid_rotate. Returns: result
duplicate_sceneB
Copy a scene and its clips; the copy goes right below it.
Parameters:
scene_index: The scene to copy
Inputs: scene_index (required). Returns: result
duplicate_to_arrangementA
Copy a Session clip into the Arrangement, on the same track. Repeat the call for every place the clip should play, then switch_to_arrangement_view to look at the result.
Parameters:
track_index: The track holding the Session clip
clip_index: Its Session slot
destination_time: Song position in beats where the copy starts
Inputs: clip_index (required), track_index (required), destination_time (required). Returns: result
duplicate_trackA
Copy a track with its clips and devices; the copy goes right after it.
Parameters:
track_index: The track to copy
Inputs: track_index (required). Returns: result
edit_warp_markersA
Edit the warp markers of a warped audio clip (Live 11+), in this order: remove, then move, then add. get_clip_warp shows the current ones.
Parameters:
track_index: An audio track
clip_index: Session slot, or position in get_arrangement_clips
location: "session" (default) or "arrangement"
add: [{"beat_time": 8.0, "sample_time": 3.66}] pins a moment of the file (seconds) to a beat
move: [{"beat_time": 8.0, "beat_time_distance": 0.25}] shifts that marker by some beats
remove: [8.0, 16.0] beat times of markers to delete
Inputs: clip_index (required), track_index (required), add, move, +2 more. Returns: result
end_undo_groupB
Close the undo group opened with start_undo_group.
Inputs: no named parameters. Returns: result
fire_clipC
Launch a Session clip.
Parameters:
track_index: The track
clip_index: The Session slot
Inputs: clip_index (required), track_index (required). Returns: result
fire_sceneC
Launch every clip in a scene's row.
Parameters:
scene_index: The scene to launch
Inputs: scene_index (required). Returns: result
get_arrangement_clipsB
The clips a track has in the Arrangement, in time order, with their position, length and type. Their order is the clip_index other tools use.
Parameters:
track_index: The track
Inputs: track_index (required). Returns: result
get_audio_clip_fileB
Path of the audio file behind an audio clip (for example a take just recorded with record_arrangement), with its length and sample rate.
Parameters:
track_index: The track holding the clip
clip_index: Arrangement clip index (get_arrangement_clips) or Session slot
location: "arrangement" (default) or "session"
Inputs: clip_index (required), track_index (required), location. Returns: result
get_browser_items_at_pathA
What a browser folder contains, with each item's URI and whether it can be loaded (load it with load_instrument_or_effect).
Parameters:
path: "root/folder/subfolder", e.g. "drums/Drum Rack" or "plugins/Arturia". Roots: instruments, sounds, drums, audio_effects, midi_effects, plugins, user_library, packs, samples, max_for_live, current_project
Inputs: path (required). Returns: result
get_browser_treeA
The folders of Live's browser, as an indented outline with the path of each folder (use the paths with get_browser_items_at_path).
Parameters:
category_type: "all", or one root: instruments, sounds, drums, audio_effects, midi_effects, plugins, user_library, packs, samples, max_for_live, current_project
Inputs: category_type. Returns: result
get_clip_automationB
Read a clip's envelope for one parameter, sampled every resolution
beats; has_envelope=false when that parameter isn't automated in the clip.
Parameters:
track_index, clip_index, location: as for set_clip_automation
device_index, parameter_index, mixer_parameter: as for set_clip_automation
resolution: Sampling step in beats (default 1)
Inputs: clip_index (required), track_index (required), location, resolution, +3 more. Returns: result
get_clip_loopB
A clip's loop switch, loop brace and start/end markers, and what actually plays. Beats, except seconds for an unwarped audio clip ("units" says which). Arrangement clips also report their place in the song.
Parameters:
track_index: The track
clip_index: Session slot, or position in get_arrangement_clips
location: "session" (default) or "arrangement"
Inputs: clip_index (required), track_index (required), location. Returns: result
get_clip_notesA
All the MIDI notes of a clip: pitch, start_time, duration, velocity, mute (plus probability and velocity deviation when Live has them). Times are in beats from the clip start. For an Arrangement clip the reply also has arrangement_start / arrangement_end and start_marker: without looping, a note sounds at arrangement_start + (start_time − start_marker).
Parameters:
track_index: The track
clip_index: Session slot, or position in get_arrangement_clips
location: "session" (default) or "arrangement"
Inputs: clip_index (required), track_index (required), location. Returns: result
get_clip_warpC
An audio clip's warp state: warping, warp mode (and the modes on offer), warp markers (beat_time ↔ sample_time in seconds), transposition, gain, clip length and file duration.
Parameters:
track_index: The track
clip_index: Session slot, or position in get_arrangement_clips
location: "session" (default) or "arrangement"
Inputs: clip_index (required), track_index (required), location. Returns: result
get_device_infoB
One device's identity (Live's real device name even when a preset renamed it, kind, latency) and its specific API: sidechain routing and options (Compressor), plug-in presets, Simpler sample/slicing state, rack chains and variations.
Parameters:
track_index / device_index: The device
track_type: "track", "return" or "master"
Inputs: track_index (required), device_index (required), track_type. Returns: result
get_device_parametersA
Every parameter of a device with its index, value, range and the value as Live displays it (dB, Hz, %, mode names).
Parameters:
track_index: The track (return index for "return", ignored for "master")
device_index: Position of the device in the chain
track_type: "track" (default), "return" or "master"
Inputs: track_index (required), device_index (required), track_type. Returns: result
get_drum_mapA
The Drum Rack on a track: every filled pad (MIDI note, name, devices) and the role each one plays (kick, clap, closed_hat, open_hat, rim, ride, perc...), read from the pad names, as used by write_drum_pattern.
Parameters:
track_index: Track holding the Drum Rack
Inputs: track_index (required). Returns: result
get_groove_poolA
Live's Groove Pool: the grooves loaded in the set (name, base, timing, random, velocity and quantization amounts) and the global Groove amount. Grooves live in the browser under Packs (e.g. get_browser_items_at_path("packs/Core Library/Grooves")) and in the User Library; apply one with set_clip_groove. A groove only acts when the global amount is above 0 (set_groove_params global_amount).
Inputs: no named parameters. Returns: result
get_recording_statusB
State of the current or last record_arrangement run (finished, reason, stop position), plus Arrangement Record, transport and armed tracks.
Inputs: no named parameters. Returns: result
get_remote_script_infoA
Version and command list of the AbletonStudioMCP control surface running
in Live, compared with this server. Use it when tools say Live is too old
or not responding (ableton-studio-mcp doctor checks the whole setup).
Inputs: no named parameters. Returns: result
get_scenesA
List the Session scenes with their index, name and tempo.
Inputs: no named parameters. Returns: result
get_session_infoA
Overview of the Live set: tempo, time signature, track and return counts, main track, transport state, song length and loop.
Inputs: no named parameters. Returns: result
get_session_snapshotA
Everything in the set at once: every track with its mixer, devices, Session and Arrangement clips, plus scenes, returns, the main track and locators. Handy to compare the set before and after a series of edits.
Parameters:
include_notes: Include the MIDI notes of every clip (default true)
include_params: Include every device parameter value (default true)
Inputs: include_notes, include_params. Returns: result
get_song_scaleA
Live 12's song scale: root, scale name, intervals and the Scale Mode switch (which highlights the scale in the piano roll and drives devices set to "Use Current Scale", e.g. the Scale, Arpeggiator and Chord devices).
Inputs: no named parameters. Returns: result
get_track_infoB
One track in detail: name, mixer state, clip slots and device chain. Works for return tracks and the main track too.
Parameters:
track_index: The track (for "return", its position among returns; ignored for "master")
track_type: "track" (default), "return" or "master"
Inputs: track_index (required), track_type. Returns: result
get_track_metersA
Live's output meters right now for every track, return track and the main track (0.0-1.0 on Live's meter scale, as in the mixer). Meaningful while the song plays; listen_to_arrangement samples them for you.
Inputs: no named parameters. Returns: result
get_track_routingA
Read a track's input/output routing and monitoring, with the options Live offers for each (names as shown in Live's I/O section, in Live's language).
Parameters:
track_index: Index of the track (return index for "return", ignored for "master")
track_type: "track" (default), "return" or "master" (these two only have an output)
Inputs: track_index (required), track_type. Returns: result
import_midi_fileA
Import the notes of a Standard MIDI File (.mid) into a clip. Without track_index, only describes the file (tracks, note counts, channels, length) so you can pick midi_track / channel first.
Session: an empty slot gets a new clip as long as the notes (rounded up to a 4-beat bar) or clip_length; an existing clip receives the notes (after clearing it when replace=True). Arrangement: the clip must exist (index from get_arrangement_clips). Times are in beats; the file's tempo is ignored.
Parameters:
file_path: Absolute path of the .mid file
track_index: Target MIDI track (omit to only describe the file)
clip_index: Session slot, or Arrangement clip index
midi_track: Track of the MIDI file to import (default: all, merged)
channel: MIDI channel to keep, 0-15 (default: all)
transpose: Semitones to add to every pitch
location: "session" (default) or "arrangement"
replace: Clear the target clip's notes first
clip_length: Length in beats of a newly created Session clip
Inputs: file_path (required), channel, replace, location, +5 more. Returns: result
listen_to_arrangementA
"Listen" to the song like a mastering engineer: record the main output between two song positions (beats) onto a temporary resampling audio track, sample every track's meter during the take, then analyze it.
report="mix" (default) returns the full analyze_mix report (LUFS, true
peak, PLR, tonal balance, resonances, stereo, findings with fixes against
target) plus a spectrogram image, and each track's meter level during
the take (which tracks carry the mix). report="basic" returns only levels,
loudness per segment and a coarse spectral balance.
Plays the song in real time, so it takes as long as the passage.
Parameters:
start_time: Song position to start at (beats)
end_time: Song position to stop at (beats); add a few beats to hear reverb tails
target: Delivery target for the mix report: "streaming", "club", "classical", "broadcast" or "podcast"
report: "mix" (default) or "basic"
keep_track: Keep the recording track and its take in the set (default: delete both once analysed)
keep_audio: Keep the recorded file in the project's Samples/Recorded folder after deleting the track (default: delete it, so listening never piles up audio files in the project)
segment_seconds: Length of each loudness segment (basic report)
max_wait_seconds: Safety limit for the recording
Inputs: end_time (required), start_time (required), report, target, +4 more.
load_drum_kitC
Load a Drum Rack, then the first loadable kit found in a browser folder.
Parameters:
track_index: A MIDI track
rack_uri: URI of the Drum Rack to load first
kit_path: Browser folder holding the kits, e.g. "drums/Drum Hits"
Inputs: kit_path (required), rack_uri (required), track_index (required). Returns: result
load_instrument_or_effectA
Load a browser item — instrument, effect, preset, plug-in, User Library file — onto a track, by its URI. Effects can also go on a return track (track_type="return", track_index 0 = A) or on the main track (track_type="master"). Find URIs with get_browser_items_at_path.
Parameters:
track_index: The track (return index for "return", ignored for "master")
uri: The item's URI, e.g. "query:Synths#Operator"
track_type: "track" (default), "return" or "master"
Inputs: uri (required), track_index (required), track_type. Returns: result
music_chord_ideasA
Reharmonisation ideas for a chord (tritone substitution, ii-V preparation, relative chords, extensions, borrowed chords in the key), with the reason for each, plus the chord's notes.
Parameters:
chord: Chord symbol, e.g. "G7", "Fmaj7", "Am", "Bø", "Ebmaj7/G"
key_root: Key tonic, to suggest borrowed chords (optional)
Inputs: chord (required), key_root. Returns: result
music_scalesA
Scales and modes knowledge. Without arguments, lists all ~50 scales
(church modes, harmonic/melodic minor families, pentatonics, blues,
bebop, symmetric, Japanese, gamelan, flamenco...) with their character
and typical styles; query filters (e.g. "flamenco", "jazz", "sombre").
With root and scale, details one scale: notes spelled in the key,
degrees, characteristic note, character, styles, diatonic seventh chords
with roman numerals and functions, the other modes with the same notes,
and Live 12's scale name (for set_song_scale).
Parameters:
query: Text to filter the list
root: Tonic (e.g. "D", "Eb") to detail one scale
scale: Scale name (e.g. "dorian", "phrygian dominant", "hijaz", "harmonic minor")
Inputs: root, query, scale. Returns: result
music_stylesA
Style sheets for composing or re-arranging: without style, the list;
with it, what makes the style: tempo, metre, scales/modes, harmonic
language, typical progressions (roman numerals for write_progression),
rhythm/groove and swing amount, bass, melody, arrangement, accompaniment
patterns, and which Live devices/tools help. Styles: baroque,
classical_romantic, jazz, bossa_nova, blues, gospel_neo_soul, funk, pop,
rock, house, techno, trance, drum_and_bass, hip_hop_boom_bap, lofi, trap,
rnb, reggae, reggaeton, afrobeat, flamenco, film_epic, ambient, synthwave
(aliases such as "Bach", "lo-fi", "dnb" work).
Parameters:
style: Style name (optional)
Inputs: style. Returns: result
plugin_presetsA
A VST/AU plug-in's preset list (as the plug-in exposes it to Live), or select one by index or name (exact, else first containing the text).
Parameters:
track_index / device_index: The plug-in
preset_index / preset_name: Preset to load (omit both to list)
track_type: "track", "return" or "master"
Inputs: track_index (required), device_index (required), track_type, preset_name, +1 more. Returns: result
rack_variationA
A rack's macro variations (Live 11+): list them with the current macro values, recall one, store the current macros as a new variation, or randomize the macros (great for happy accidents, then store the result).
Parameters:
track_index / device_index: The rack
action: list | recall | store | randomize
index: Variation to recall
track_type: "track", "return" or "master"
Inputs: track_index (required), device_index (required), index, action, +1 more. Returns: result
record_arrangementA
Record the armed tracks into the Arrangement between two song positions (in beats): moves the playhead, turns Arrangement Record on, plays, and stops at end_time. Arm tracks first (set_track_arm).
Parameters:
start_time: Song position to start at (beats)
end_time: Song position to stop at (beats)
wait: Block until the recording ends (default) or return at once (then poll get_recording_status)
max_wait_seconds: Safety limit when waiting; recording is stopped past it
Inputs: end_time (required), start_time (required), wait, max_wait_seconds. Returns: result
redoA
Redo what undo just took back (as long as nothing else changed since).
Parameters:
steps: How many steps to redo (1–50)
Inputs: steps. Returns: result
remove_notesA
Remove only the notes starting inside a time window and a pitch range — to rewrite one bar, or one drum lane, then add the new notes.
Parameters:
track_index: The track
clip_index: Session slot, or position in get_arrangement_clips
from_time: Window start, in beats from the clip start
time_span: Window length in beats (default: until the clip end)
from_pitch: Lowest pitch of the range (0–127)
pitch_span: How many pitches from from_pitch (128 = all, 1 = just that note)
location: "session" (default) or "arrangement"
Inputs: clip_index (required), track_index (required), location, from_time, +3 more. Returns: result
set_arrangement_clip_nameA
Rename a clip in the Arrangement.
Parameters:
track_index: The track
clip_index: Position of the clip in get_arrangement_clips (ordered by start time)
name: Its new name
Inputs: name (required), clip_index (required), track_index (required). Returns: result
set_arrangement_timeB
Move the playhead.
Parameters:
time: Song position in beats (0 = start; in 4/4, bar N starts at 4 × (N − 1))
Inputs: time (required). Returns: result
set_clip_automationA
Draw an automation envelope inside a Session clip; it plays whenever the clip plays. (Live's API does not allow writing envelopes in Arrangement clips or the Arrangement's automation lanes.) Target a device parameter (device_index + parameter_index, see get_device_parameters) or a mixer control (mixer_parameter).
Parameters:
track_index: The track holding the clip and the parameter
clip_index: The Session slot
points: [{"time": 0, "value": 0.2}, {"time": 16, "value": 0.9}] — time in beats from the clip start, value in the parameter's own range (clamped); the last value holds to the clip end. [] with clear_first removes the envelope.
location: "session" (the only place Live accepts)
device_index: Device in the chain (ignored with mixer_parameter)
parameter_index: Parameter of that device
mixer_parameter: "volume", "panning" or "send:N" (N = return index)
interpolation: "linear" (ramps drawn in steps of
resolution) or "step"resolution: Ramp step in beats (0.25 = a sixteenth)
clear_first: Erase this parameter's envelope in the clip first
Inputs: points (required), clip_index (required), track_index (required), location, +6 more. Returns: result
set_clip_grooveA
Apply a Groove Pool groove to a clip (Live's own swing/groove engine, non-destructive), or remove it with groove_index omitted.
Parameters:
track_index / clip_index: The clip
groove_index: Index from get_groove_pool (omit to remove the groove)
location: "session" (default) or "arrangement"
Inputs: clip_index (required), track_index (required), location, groove_index. Returns: result
set_clip_loopA
Change a clip's loop and markers; anything left out stays as it is.
With looping on, playback starts at start_marker and then repeats the brace (loop_start → loop_end); e.g. keep only the first bar of a 4-bar loop with loop_start=0, loop_length=4. With looping off Live plays loop_start → loop_end once, so markers given for such a clip are written to the brace. The writes are ordered so the start never passes the end; the reply shows what Live applied and lists any value it "adjusted". Switching warping off and on again resets an audio clip's warp markers.
Parameters:
track_index: The track
clip_index: Session slot, or position in get_arrangement_clips
location: "session" (default) or "arrangement"
looping: Loop switch
loop_start, loop_end: The brace (beats; seconds for unwarped audio)
loop_length: Alternative to loop_end: loop_end = loop_start + loop_length
start_marker, end_marker: Where playback starts and ends
Inputs: clip_index (required), track_index (required), looping, location, +5 more. Returns: result
set_clip_nameC
Rename a Session clip.
Parameters:
track_index: The track
clip_index: The Session slot
name: Its new name
Inputs: name (required), clip_index (required), track_index (required). Returns: result
set_clip_warpA
Change an audio clip's warp settings; anything left out stays as it is. Give a loop's own tempo as original_bpm (sample names often carry it, "...131...") and it follows the song tempo: warping goes on and the warp markers are rebuilt for that tempo.
Parameters:
track_index: An audio track
clip_index: Session slot, or position in get_arrangement_clips
location: "session" (default) or "arrangement"
warping: Warp on or off
warp_mode: "beats" (drums), "tones" (monophonic), "texture", "re_pitch" (vinyl-like), "complex" / "complex_pro" (full mixes), or 0–6
original_bpm: The loop's own tempo
pitch_coarse: Transposition in semitones (−48…48)
pitch_fine: Detune in cents (−50…50)
gain: Clip gain 0.0–1.0 (the reply shows it in dB)
Inputs: clip_index (required), track_index (required), gain, warping, +5 more. Returns: result
set_device_parameterA
Change one device parameter. Look up indexes and ranges with get_device_parameters; the reply shows the old and new values as Live displays them.
Parameters:
track_index: The track (return index for "return", ignored for "master")
device_index: Position of the device in the chain
parameter_index: The parameter's index
value: New value, in the parameter's own range
track_type: "track" (default), "return" or "master"
Inputs: value (required), track_index (required), device_index (required), parameter_index (required), +1 more. Returns: result
set_device_sidechainA
Feed a Compressor's sidechain from another track (e.g. duck the bass or
pads with the kick) and switch its sidechain on. source is the name of
the track as Live lists it (see get_device_info: sidechain.available_types),
channel e.g. "Post FX" / "Pre FX". Live's API exposes sidechain routing
on the Compressor; other devices with a sidechain (Gate, Glue, Auto
Filter...) are routed in the interface.
Parameters:
track_index / device_index: The Compressor
source: Sidechain source track name (exact, or a unique part of it)
channel: Source tap (optional)
enable: Turn the sidechain on (default) or off
track_type: "track", "return" or "master"
Inputs: source (required), track_index (required), device_index (required), enable, +2 more. Returns: result
set_drum_chokeA
Put Drum Rack pads in a choke group so they cut each other — the classic: closed and open hi-hat together (e.g. notes [42, 46], group 1). Group 0 removes the choke.
Parameters:
track_index: Track with the Drum Rack
notes: Pad MIDI notes (see get_drum_map)
group: Choke group 1-16, or 0 for none
Inputs: notes (required), track_index (required), group. Returns: result
set_groove_paramsA
Adjust a groove in the Groove Pool (amounts in %, as in Live) and/or the global Groove amount (0-1.3, i.e. 0-130 %).
Parameters:
groove_index: Groove to change (from get_groove_pool)
timing_amount / random_amount / velocity_amount / quantization_amount: New amounts
global_amount: Global Groove amount
Inputs: groove_index, global_amount, random_amount, timing_amount, +2 more. Returns: result
set_scene_nameC
Rename a scene.
Parameters:
scene_index: The scene to rename
name: Its new name
Inputs: name (required), scene_index (required). Returns: result
set_song_scaleA
Set Live 12's song scale so the piano roll shows it and scale-aware
devices follow it. scale accepts this server's names (dorian, hijaz,
harmonic minor...) and maps them to Live's name when Live has the scale.
Parameters:
root: Tonic ("C", "Eb", "F#")
scale: Scale name
scale_mode: Turn Live's Scale Mode on/off
Inputs: root, scale, scale_mode. Returns: result
set_tempoB
Change the song tempo.
Parameters:
tempo: Beats per minute (Live accepts 20–999)
Inputs: tempo (required). Returns: result
set_track_armB
Arm a track for recording, or disarm it.
Parameters:
track_index: The track
arm: true arms, false disarms
Inputs: arm (required), track_index (required). Returns: result
set_track_muteB
Mute or unmute a track.
Parameters:
track_index: The track
mute: true mutes, false unmutes
track_type: "track" (default) or "return"
Inputs: mute (required), track_index (required), track_type. Returns: result
set_track_nameC
Rename a track.
Parameters:
track_index: The track to rename
name: Its new name
Inputs: name (required), track_index (required). Returns: result
set_track_panningB
Pan a track.
Parameters:
track_index: The track (ignored for "master")
panning: -1.0 hard left, 0.0 centre, 1.0 hard right
track_type: "track" (default), "return" or "master"
Inputs: panning (required), track_index (required), track_type. Returns: result
set_track_routingA
Set a track's input/output routing and monitoring. Arguments left out are untouched. Names are matched against the options get_track_routing lists: exact (case-insensitive) first, else a unique substring.
Examples:
Layer one MIDI part on several instruments: on each extra MIDI track, input_type="", monitoring="in".
Record the main output (resampling): on an audio track, input_type="Resampling" (French Live: "Rééchantillonnage").
Send a track to a return or another track: output_type="".
Parameters:
track_index: Index of the track (return index for "return")
input_type / input_channel: Input routing ("MIDI From" / "Audio From")
output_type / output_channel: Output routing ("MIDI To" / "Audio To")
monitoring: "in", "auto" or "off"
track_type: "track" (default), "return" or "master" (output only)
Inputs: track_index (required), input_type, monitoring, track_type, +3 more. Returns: result
set_track_sendB
Set how much of a track goes to a return track.
Parameters:
track_index: The sending track
send_index: Which send (0 = A, the first return track)
value: Send amount 0.0–1.0
track_type: "track" (default) or "return"
Inputs: value (required), send_index (required), track_index (required), track_type. Returns: result
set_track_soloC
Solo or unsolo a track.
Parameters:
track_index: The track
solo: true solos, false unsolos
track_type: "track" (default) or "return"
Inputs: solo (required), track_index (required), track_type. Returns: result
set_track_volumeA
Move a track's fader.
Parameters:
track_index: The track (ignored for "master")
volume: Fader position 0.0–1.0 (0.85 is 0 dB, 0.0 is silence)
track_type: "track" (default), "return" or "master"
Inputs: volume (required), track_index (required), track_type. Returns: result
simpler_sampleB
Load a sample into a Simpler and set it up: playback mode (classic, one_shot, slicing), slicing by transient / beat / region / manual with sensitivity, beat division or region count (e.g. chop a break into 16 slices playable from a Drum Rack-like MIDI layout), voices, warp the sample as N beats, crop, reverse.
Parameters:
track_index / device_index: The Simpler
file_path: Absolute path of an audio file to load (optional)
playback_mode: classic | one_shot | slicing
slicing_style: transient | beat | region | manual
slicing_sensitivity: 0-1 (transient mode)
slicing_beat_division: Live's beat division index (beat mode)
slicing_region_count: Number of slices (region mode)
voices: Polyphony
warp_as_beats: Warp the sample to this many beats
crop / reverse: Destructive edits of the sample in Simpler
Inputs: track_index (required), device_index (required), crop, voices, +8 more. Returns: result
start_playbackA
Start the transport (plays from the playhead).
Inputs: no named parameters. Returns: result
start_undo_groupA
Start grouping: every change until end_undo_group becomes a single undo step, so a whole request ("8 bars of techno with a bassline") can be taken back at once. Always call end_undo_group afterwards; a group left open is closed automatically after two minutes.
Parameters:
name: What the group is for (shown in Live's log)
Inputs: name. Returns: result
stop_arrangement_recordingA
Stop a running record_arrangement now (turns Arrangement Record off and stops playback).
Inputs: no named parameters. Returns: result
stop_clipC
Stop a playing Session clip.
Parameters:
track_index: The track
clip_index: The Session slot
Inputs: clip_index (required), track_index (required). Returns: result
stop_playbackC
Stop the transport.
Inputs: no named parameters. Returns: result
switch_to_arrangement_viewB
Bring Live's Arrangement view to the front.
Inputs: no named parameters. Returns: result
transform_clipA
Re-arrange a MIDI clip with a chain of music-theory operations, applied in
order. Writes the result back into the clip, or into an empty Session slot
target_clip_index (keeps the original: safer for trying ideas).
Each operation is {"op": name, ...arguments}:
transpose: semitones
transpose_diatonic: steps, root, scale (moves along the scale)
change_mode: root, from_scale, to_scale[, to_root] (C major -> C dorian...)
snap_to_scale: root, scale[, direction nearest|up|down]
invert: axis ("C4" or 60)[, root, scale for a diatonic mirror]
retrograde: [length]
time_scale: factor (2 = half speed, 0.5 = double)
quantize: [grid=0.25, strength=1.0, durations=false]
swing: [amount_pct=60 (50 straight, 66.7 triplet), grid=0.5]
humanize: [timing=0.01 beats, velocity=8, seed=0]
accent: [pattern=[1,0.7,0.85,0.7], grid=1.0, base=110]
articulate: factor (0.5 = staccato) or legato=true
fold_range: low, high (e.g. "C3", "C5")
harmonize: root, scale[, steps=[2] (2 = third above, -2 below, 4 fifth, 5 sixth), keep_original=true]
arpeggiate: [rate=0.25, pattern up|down|updown|random, octaves=1, gate=0.9]
strum: [spread=0.03, direction down|up]
voice_chords: voicing close|drop2|open|spread Notes are written as C4 = MIDI 60 (Live displays it as C3).
Parameters:
track_index / clip_index: Source clip
operations: List of operations (see above)
location: "session" (default) or "arrangement"
target_clip_index: Empty Session slot on the same track for the result (optional)
Inputs: clip_index (required), operations (required), track_index (required), location, +1 more. Returns: result
undoA
Undo the last change(s) in Live, like Cmd/Ctrl+Z. Each tool call that changed the set is one step; tools that make many changes at once (drum patterns, progressions, arrangements, MIDI imports…) are one step too, as is everything between start_undo_group and end_undo_group. It is Live's own Undo: if the user edited the set meanwhile, their change comes first.
Parameters:
steps: How many steps to undo (1–50)
Inputs: steps. Returns: result
write_clip_evolutionA
Make a Session clip evolve over many bars: optionally extend it to bars
(a MIDI loop is tiled, e.g. 4 -> 64 bars), then write one automation
envelope per lane with a musical curve. Copied to the Arrangement (e.g.
by build_arrangement), the envelopes become the track's automation there.
Each lane: {"mixer_parameter": "volume" | "panning" | "send:N"} or {"device_index": d, "parameter_index": p}, plus "start", "end" (in the parameter's units, see get_device_parameters: min/max/display), "shape" (linear, exp, log, s_curve, swell, sine, triangle, steps, random_walk, hold), optional "cycles" (sine/triangle), "steps" (steps), "power" (exp/log curvature, default 2.5), "from_bar"/"to_bar" to limit the curve to part of the clip (the value holds outside), "seed".
Example, a 64-bar techno build: filter cutoff exp from 0.3 to 0.9, reverb send swell, hats volume in 8 steps.
Parameters:
track_index / clip_index: Session clip
lanes: Curves to write (see above)
bars: Extend the clip to this many bars first (MIDI clips; 4/4)
resolution: Envelope step in beats (1 = a point per beat)
Inputs: lanes (required), clip_index (required), track_index (required), bars, +1 more. Returns: result
write_drum_patternA
Program drums into a Session slot (clip created to fit) on a track with a Drum Rack. Roles are mapped to the kit's pads by their names (a similar free pad stands in for a missing role; missing ones are reported); without a Drum Rack, General MIDI notes are used.
Start from a library style and/or give layers: {role: grid} or
{role: {"euclid": [hits, steps, rotate]}}; layers override or extend the
style. Roles: kick, clap, snare, rim, closed_hat, open_hat, pedal_hat,
ride, crash, tom_low, tom_mid, tom_high, perc, shaker, tambourine, conga,
bongo, clave, cowbell, fx. A grid shorter or longer than a bar cycles
over the whole clip (a 12-step loop drifts against 16-step bars).
Grid: x hit · X accent · o ghost · . rest · 2/3/4 ratchet · ? 50 % · * 25 % ghost
(probabilities use Live 12's per-note chance, so the loop varies as it plays).
Parameters:
track_index / clip_index: Drum track and Session slot
style: Library pattern (see drum_patterns)
layers: Extra or replacement grids per role
bars: Clip length in bars (4/4)
steps_per_bar: Grid resolution (16 = 16ths, 12 = 8th-note triplets, 32)
swing_pct: Swing on odd steps, 50 = straight (default: the style's)
fill: Every
fill_everybars: roll, drop, open_hat, ratchet or crashvariation: 0-1, chance of extra ghost hats (written with low probability)
humanize: Timing spread in beats (e.g. 0.005), with small velocity changes
replace: Clear an existing clip in the slot first
seed: Random seed for variation/humanize
Inputs: clip_index (required), track_index (required), bars, fill, +9 more. Returns: result
write_progressionA
Write a chord progression into an empty Session slot (clip created to fit) or an existing clip, voiced with smooth voice leading and played with an accompaniment pattern.
Give numerals (roman numerals in the key: "ii7", "V7", "Imaj7",
"bVII", "iv", "V/V", "N6", "viiø7"...) or a style (its typical
progression number progression_index, its scale and pattern are used
unless given). Patterns: block, pulse, pulse8, offbeat, arp8, arp16,
alberti, bossa, waltz, ballad, stabs.
Parameters:
track_index / clip_index: Target MIDI track and Session slot
root: Key tonic ("C", "F#", "Bb")
scale: Scale/mode of the key (default major)
numerals: Roman numerals (optional if style)
style: Style name (see music_styles)
progression_index: Which of the style's progressions
beats_per_chord: Harmonic rhythm (4 = one chord per bar)
pattern: Accompaniment pattern (default: the style's first, else block)
low / high: Range of the chord voicings
bass: Add a bass line (root, an octave or two below)
repeat: Times to repeat the progression
voices: Notes per chord voicing (3-5)
Inputs: root (required), clip_index (required), track_index (required), low, +10 more. Returns: result
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
TDQS
Scored across 96 tools
Most tools map to a distinct DAW object or action, and detailed descriptions disambiguate close pairs such as set_clip_automation vs write_clip_evolution and analyze_audio_file vs analyze_mix. There are still several near-overlapping analysis, knowledge, and device-inspection tools, but clear boundaries generally exist.
Most action tools use a consistent snake_case verb_noun pattern (get_, set_, create_, delete_, write_, build_), while informational catalog tools use noun phrases (device_inventory, music_styles). The deviations are minor and readable.
96 tools is far beyond a practical tool set and well past the 25+ 'too many' threshold, even for a deep DAW controller. Many related operations could be consolidated, and the volume increases selection risk.
The surface covers session control, tracks, clips, MIDI editing, devices, browser access, routing, recording, mix analysis, and music generation/arrangement in depth. Remaining gaps are relatively minor, such as return-track lifecycle and device-chain reordering/deletion.
Maintenance
Related MCP Connectors
Generate AI music via the Lacuna Music API from MCP clients like Claude Desktop & Code.
Remote MCP server for audio stem separation, denoise, reverb, and MIDI export.
MCP server for Producer/Riffusion AI music generation
Compose, mix, master and export in Logic Pro, REAPER or Ableton Live by talking to an AI engineer.
Related MCP Servers
- AlicenseBqualityDmaintenanceConnects Ableton Live to Claude AI via the Model Context Protocol for prompt-assisted music production and session manipulation. It enables users to create tracks, load instruments, and manage MIDI clips using natural language commands.161MIT
- AlicenseBqualityDmaintenanceConnects Claude AI to Ableton Live via the Model Context Protocol, enabling prompt-assisted music production, track and clip manipulation, and session control.16MIT
- AlicenseBqualityDmaintenanceConnects Ableton Live to Claude AI via the Model Context Protocol, enabling prompt-assisted music production, track creation, and Live session manipulation.16MIT
- AlicenseBqualityDmaintenanceConnects Ableton Live to Claude AI through the Model Context Protocol, enabling AI-assisted music production and direct control of Ableton Live sessions.100MIT