Skip to main content
Glama

Tonable

Tonable — connect your assistant to Ableton Live

Tonable connects a local MCP assistant to Ableton Live 12.4+. Read a Live Set, load devices and presets, write MIDI notes, shape automation and arrange scenes through 31 tools. Tonable runs on your Mac: the assistant starts an MCP server over stdio, and a Remote Script executes commands inside Live.

Version 0.6.1. The tools were exercised in Live 12.4.16, including most of the 0.6 additions (everything marked new in the tool reference); the tool reference and the manual checklist list what has not been run in Live yet. Repeat the checklist on your installation in a disposable Set. Tonable is an independent project, unaffiliated with Ableton AG.

What you can do

  • Inspect tracks, rack chains, Drum Rack pads, parameters, clips and scenes.

  • Search Core Library, Packs and User Library; load devices and presets.

  • Change mixer settings, routing (with channels), monitoring, crossfader assignment, device parameters and rack macros.

  • Control the Set: record, overdub, punch, quantization, groove amount, Link, scale mode, locators, and transport actions such as capture MIDI.

  • Create and edit MIDI clips (Session or timeline) with note probability, velocity deviation and release velocity; transpose, shift, quantize and mute notes.

  • Set every clip property: loop and markers, launch mode and quantization, clip scale, groove; for audio clips warp mode and markers, gain and pitch.

  • Put audio files on audio tracks; convert audio to MIDI, Simpler or Drum Rack.

  • Configure device internals no parameter exposes: Simpler, Wavetable, Drift, Meld, Compressor sidechain, EQ Eight, Hybrid Reverb, Roar, Looper, rack chains.

  • Read and write Session automation, including ramps, jumps and curves.

  • Copy or move timeline clips, copy whole scenes to Arrangement, add take lanes and locators.

  • Drive Live's windows, selection and browser preview; tune the groove pool.

  • Reach any other Live API member with the guarded live_api tool.

  • Group edits into one undo step with batch; inspect .adg and .adv files without opening Live.

See the tool reference and examples for addresses, arguments and limitations.

Related MCP server: AbletonMCP

Requirements

  • macOS for the validated Live workflow. The installer recognizes macOS and Windows library locations and accepts an explicit path on any OS. Windows discovery is unit-tested; end-to-end Live support on Windows is unverified. Preset discovery still uses macOS Core Library paths.

  • Ableton Live 12.4 or newer, installed and started at least once. Devices and presets must be available in your Live edition and installed packs. Max for Live is only needed for devices that require it.

  • uv with Python 3.11+. The commands below ask uv to provide Python 3.11 if needed; no separate Python setup is required.

  • A local MCP client that can launch a stdio process under the same macOS user as Live. Client accounts and subscriptions are separate from Tonable.

Install without a checkout

Get the wheel, source archive and SHA-256 checksums from the GitHub release. CI builds and checks each release before publishing its files. You can run the versioned wheel URL directly, without cloning the repository:

uvx --python 3.11 --from https://github.com/iamursky/tonable/releases/download/v0.6.1/tonable-0.6.1-py3-none-any.whl tonable libraries
uvx --python 3.11 --from https://github.com/iamursky/tonable/releases/download/v0.6.1/tonable-0.6.1-py3-none-any.whl tonable install

The installer lists existing libraries found in Live's preferences. If there are several, select one; then confirm the displayed path. It only offers the existing OS default when no configured path is known. An unavailable configured path is reported; reconnect its drive or pass a verified path explicitly. The installer never creates a guessed library. In unattended use, supply --user-library PATH; --yes can confirm a single detected candidate but cannot resolve ambiguity.

To check a specific destination before copying, use the User Library root from Live's Settings → Library, not the Remote Scripts folder:

uvx --python 3.11 --from https://github.com/iamursky/tonable/releases/download/v0.6.1/tonable-0.6.1-py3-none-any.whl tonable install \
  --user-library "/path/to/User Library" --dry-run

Remove --dry-run to install. An explicit path can create a new library folder, which is also useful for staging. Files are copied from the package into <User Library>/Remote Scripts/Tonable. Existing Tonable files require --replace; other Remote Scripts stay in place. Symlinked script destinations are refused. Copying is staged before replacement. The installer does not change Live preferences, select a Control Surface or contact Live unless you add --reload. Close Live before replacing a component for a release check.

  1. Restart Live after installing.

  2. Open Settings → Link, Tempo & MIDI → Control Surface and choose Tonable. Leave Input and Output set to None.

  3. Run tonable doctor using the persistent install below, or run doctor through the same uvx --from ... tonable command. For a custom library, pass --user-library "/path/to/User Library". All checks should show OK.

For a persistent CLI, independent of both the checkout and the wheel's location:

uv tool install --python 3.11 https://github.com/iamursky/tonable/releases/download/v0.6.1/tonable-0.6.1-py3-none-any.whl
uv tool dir --bin

Use the tonable executable in that bin directory for setup and client commands. You can replace the URL with an absolute path to a downloaded wheel. For uvx, keep a local wheel at the configured path: its environment may need to be rebuilt. See the official uv tools guide for tool isolation.

PyPI publication uses a separate Trusted Publishing job. Once version 0.6.1 is listed on the project's PyPI page, you can use a pinned registry source:

uvx --python 3.11 --from 'tonable==0.6.1' tonable install
uvx --python 3.11 --from 'tonable==0.6.1' tonable serve

The release workflow verifies the registry upload, file hashes and tool discovery. If PyPI publication has not succeeded, use the GitHub wheel URL above.

Install from source for development

uv sync --locked
uv run tonable install --dry-run
uv run tonable install

Connect an assistant

Tonable exposes MCP over stdio only. Use the local setup for your client:

The examples follow official client documentation. They describe a compatible transport; they do not certify every client version. Tonable has no HTTP/SSE endpoint or hosted connector. The private loopback socket inside Live is not an MCP URL. See client setup for sources and verification steps.

Start with a read-only request:

Use Tonable to check the Live connection and summarize the open Set. Do not edit it.

For an editing example, use a disposable empty Set:

Create a MIDI track called Sketch. Add a four-bar Session clip with C3, E3 and G3 on its first beat. Read the clip back and report any rejected notes. Do not start playback.

A MIDI clip needs an instrument before it produces sound. Ask the assistant to read the current addresses before editing; track and device indices can change.

Updates and removal

Obtain the new trusted wheel, close Live, and replace the persistent package:

uv tool install --force --python 3.11 /absolute/path/to/new-tonable.whl
tonable install --replace
tonable doctor

Restart Live before running doctor, then reconnect the MCP server so the client refreshes its tools. For an existing component from 0.3.0 onward, tonable install --replace --reload can request a command-module reload. It does not replace a restart for socket-layer changes or a failed reload. With a uvx client configuration, update its wheel path as well.

To remove the component, run tonable uninstall, confirm the library and removal, then set its Control Surface slot to None and remove the MCP client entry. For unattended removal, use tonable uninstall --user-library PATH --yes. --dry-run previews removal. To remove the persistent CLI, use uv tool uninstall tonable. Runtime reports and ~/.tonable are left in place.

Data and editing behavior

The Remote Script binds only to 127.0.0.1 on an OS-assigned port. It generates a random access key and writes ~/.tonable/session.json with owner-only permissions. Tonable itself has no hosted service and requires no API key. Your MCP client may send tool results, including Set names and preset paths, to its model provider. Never share the session file or commit local reports without reviewing them.

Edits use Live's shared undo history. batch groups changes into one step but is not a transaction: successful actions remain applied if another action fails. After a timeout or lost connection, read the state before retrying an edit. Saving Sets, exporting audio and freezing tracks are outside Tonable's API.

Development

uv sync --locked
uv run pytest
uv run ruff check .
uv run ruff format --check .
uv build
uv run python scripts/check_distribution.py \
  --wheel dist/tonable-0.6.1-py3-none-any.whl \
  --sdist dist/tonable-0.6.1.tar.gz --python 3.11

Tests use a fake Live API and local loopback sockets. They do not prove audio quality or replace checks inside Live. The optional Live API probe is developer diagnostics; normal installation does not need it and the installed wheel excludes it.

See architecture and publication checks.

Acknowledgments and license

Tonable draws on techniques from ableton-live-mcp and Producer Pal. Attribution and their MIT notices are in THIRD_PARTY_NOTICES.md.

Tonable is licensed under MIT, © 2026 Ilya Amursky. Ableton software and content are not included and remain subject to their own licenses.

Available Tools

31 tools
appA

Live's own interface and state.

info: Live version, CPU load, open dialogs (read only: Tonable never presses a dialog button) and what is selected, as Tonable addresses. select: select a track, scene, clip, device or parameter so the user sees it in Live. show_view, hide_view, focus_view, toggle_browse, scroll_view, zoom_view: arrange Live's windows. set_view: follow_song and draw_mode. show_message: a status-bar message. preview and stop_preview: audition a browser item (a sound or preset) without loading it. Selection and view changes are not undo steps.

Inputs: action (required), item, view, target, +6 more.

arrangementA
Destructive

Work on the Arrangement timeline.

list: clips per track, locators, loop. place_scene: copy every clip of a Session scene to the timeline at a bar, in one undo step (envelopes come along as track automation). copy_clip: one Session or timeline clip to a bar. move_clip: a timeline clip (t0/a1) to another bar. create_clip: a MIDI clip on the timeline with notes (audio: create_audio_clip). delete_clip: by track, start and name. add_take_lane. add_locator, rename_locator, delete_locator. list shows each clip's address, type and the take lanes. Times answer as bar|beat ("17|1") and beats. Live cannot read Arrangement automation back.

Inputs: action (required), clip, name, slot, +7 more.

batchA
Destructive

Run several Tonable tools in one go, as ONE undo step (one Cmd+Z undoes them all). Each action gets its own result; a failed one does not stop the rest unless stop_on_error is set. Arguments are passed as given, so use the forms the tools document.

Inputs: actions (required), stop_on_error.

configure_deviceA
Destructive

Read, set and run the device-specific things that are not parameters: Simpler playback mode, sample, slices and warp actions; Wavetable voices, oscillator wavetables and modulation matrix; Drift and Meld voicing and modulation sources; Compressor sidechain source; EQ Eight mode; Hybrid Reverb impulse responses; Roar, Shifter, Spectral Resonator and Looper; rack chains, Drum Rack pads and copy_pad; a device's collapsed state and A/B compare.

Call it with only a target to see the settings (current value, options or range) and actions that target has on this Live. Settings are checked and read back: each gets its own result line, a value Live refuses says so, and the others still apply. Targets: a device, a rack chain (t0/d0/c1) or a Drum Rack pad (t0/d0/pC1, which writes to every chain on the pad). The actions reverse, crop, clear and delete_all_chains change content; one undo step undoes them.

Inputs: target (required), args, action, settings.

convert_audioA

The conversions behind Live's Convert menu. audio_to_midi: an audio clip becomes a MIDI clip on a new track (drums, melody or harmony). to_simpler: a new MIDI track with a Simpler holding the clip's sample. to_drum_rack: a new track with a Drum Rack, the sample on pad C1. slices_to_drum_rack: a sliced Simpler becomes a Drum Rack with a pad per slice. pad_to_track: a Drum Rack pad's chain gets its own MIDI track. move_devices_to_drum_rack: a track's devices move onto pad C1 of a new Drum Rack.

Live runs the conversion a moment after the answer, so use read_set afterwards to find the new track; track numbers after it may shift. MIDI clips and clips that are recording are refused. One undo step.

Inputs: action (required), clip, type, track, +1 more.

create_audio_clipA

Put an audio file on an audio track as a Session clip (empty slot) or as a timeline clip (at_bar or at_beats). Say the clip's address and its audio details.

The track must be an audio track; MIDI tracks load samples through load_device. Only audio files are accepted. One undo step.

Inputs: path (required), clip, name, slot, +3 more.

create_trackA

Add a MIDI, audio or return track and say its address. A new return track gets the next letter (rB after rA); load an effect on it with load_device and send to it with update_track sends. One undo step.

Inputs: kind, name, index.

deleteA
Destructive

Delete a track, return track, device, clip (t0/s2) or scene (s2).

Give its current name as a check: without the right name nothing is deleted. One undo step; undo brings it back.

Inputs: name (required), target (required).

duplicateA

Copy a track, scene, clip or device; the copy goes right after the original (a clip can go to another empty slot with to_slot). Says the copy's address. One undo step.

Inputs: target (required), to_slot.

edit_notesA
Destructive

Change some notes of a MIDI clip without rewriting it: delete, transpose, shift in time, quantize starts to a grid, set velocity or length, mute or unmute, set probability, velocity deviation or release velocity.

Choose notes by start time (from_beats/to_beats) and pitches; with neither, all notes. Notes that would leave the MIDI range or the clip start are skipped and listed. One undo step. To replace all notes use write_clip.

Inputs: action (required), clip, slot, beats, +9 more.

find_in_libraryA
Read-onlyIdempotent

Search Live's browser: devices, presets (.adg, .adv) and samples in the Core Library, Packs and User Library. Returns paths for load_device.

The first search walks the whole browser (about 5 s, Live pauses briefly); later ones are instant. Exact names come first. Places are not searchable: Live does not show them to scripts.

Inputs: query (required), kind, limit, refresh.

grooveA
Idempotent

Read the groove pool and tune its grooves: grid, timing, quantize, random and velocity amounts, and the Set's global groove amount.

Live's API cannot create or remove grooves, and cannot clear a clip's groove; it can only change the grooves already in the pool. Assign a groove to a clip with update_clip. Each field gets its own result line with what Live holds afterwards (Live ignores some invalid writes, so check "now"). One undo step.

Inputs: action (required), base, name, groove, +5 more.

inspect_preset_fileA
Read-onlyIdempotent

What a preset file holds, without loading it and without Live: the device, a rack's visible macro names, its chains (or Drum Rack pads with their notes) and the devices in each, nested racks included.

Inputs: path (required).

live_apiA
Destructive

Escape hatch to Live's object model for anything the other tools do not cover: Song, view, device, clip or mixer properties and methods.

Start with info on the object to see its members, then get, set or call. Set and call need write=true, change one undo step, and say what Live holds after (Live silently keeps the old value for some invalid writes). Prefer the dedicated tools when one exists; they check more. Results are plain JSON: Live objects come back as {object, name, address}. Underscore names, modules and files are never reachable.

Inputs: path (required), operation (required), args, name, +5 more.

live_statusA
Read-onlyIdempotent

Check the connection to Ableton Live and show the open Set.

Returns whether Live is connected, the Live and Tonable versions, and the Set's tempo, time signature and numbers of tracks, return tracks and scenes. When Live is not reachable it returns connected=false with the reason and what to do. Use it first in a conversation and after any connection error.

Inputs: no named parameters.

load_deviceA
Destructive

Load a device or preset onto a track and return its address and, for a rack, its macro names.

Built-in devices go exactly at index. Presets load like a drag from the browser: an instrument replaces the track's instrument (the answer names what it replaced). A file outside the User Library and Packs is refused with a hint to move it into the User Library. Live selects the track it loads onto.

Inputs: item (required), target (required), index.

read_clipA
Read-onlyIdempotent

A clip, Session (track + slot, or clip t0/s2) or timeline (clip t0/a1): name, length, loop, and under settings its color, mute, markers, launch mode and quantization, legato, scale, time signature and groove. An audio clip adds its file, warp mode, gain, pitch and warp markers. A MIDI clip lists every note with pitch name and number, start and length in beats, velocity, and (when not default) probability, velocity deviation and release velocity.

Use it before changing notes and to check what write_clip or update_clip did.

Inputs: clip, slot, track.

read_deviceA
Read-onlyIdempotent

A device's parameters as Live shows them ("262 ms", "-6.0 dB", "On"), with raw value and range, plus whether the device is on.

For a rack: its visible mapped macro knobs and its chains, not every parameter (set all_params to see them all). For other devices: all parameters. Give params to see only some, by name; a wrong name comes back with similar names. A chain or pad address shows its devices instead.

Inputs: target (required), params, all_params.

read_envelopeA
Read-onlyIdempotent

The automation points of one parameter in a Session clip: time in beats, value as Live shows it, raw value, and curve bends. exists=false when the clip has no envelope for it.

Inputs: slot (required), track (required), parameter (required).

read_setA
Read-onlyIdempotent

Overview of the open Live Set: tempo, time signature, loop, tracks, return tracks, scenes and locators.

Each scene lists the clips in its row as {track address: clip name}; empty slots are left out. Each track shows its address, name, kind (midi, audio, group) and device names. Use read_track for one track's mixer, devices and clips.

Inputs: no named parameters.

read_trackA
Read-onlyIdempotent

One track in detail: mixer (volume, pan, sends to each return), input and output routing, the device tree with rack chains and Drum Rack pads, Session clips by slot, and Arrangement clips.

Every device comes with its address (t1/d0/c0/d1) for read_device. Also shows monitoring, crossfader assignment, freeze state and the playing slot. Works for return tracks (rA) and the master (m) too.

Inputs: track (required).

sceneA

Create a scene, rename it or set its tempo, time signature and color, duplicate it, or capture the playing clips into a new scene. Delete scenes with delete (target s2). Launch one with transport fire_scene. One undo step.

Inputs: action (required), name, index, scene, +3 more.

set_device_paramsA
Idempotent

Set one or more parameters of a device or rack macro, by name, in the units Live shows ("400 ms", "-6 dB", "50 %", "On") or as raw numbers.

Each parameter gets its own line: "now" is what Live shows afterwards, a wrong name comes back with similar names, and one failure never stops the others. If a parameter has automation, Live stops playing it (the answer warns; use transport re_enable_automation). One undo step.

Inputs: params (required), target (required).

transportA

Play, stop or continue; launch a clip (fire_clip track+slot, also records into an empty slot of an armed track) or a scene (fire_scene); stop one clip (stop_clip), one track's clips (stop_track) or all clips; jump to a time in beats (jump), by a distance (jump_by), to a locator, or to the next or previous locator; jump_in_clip inside the clip a track is playing; play_selection; tap_tempo; capture_midi (keep what was just played); trigger_session_record; back_to_arranger (leave Session playback); re_enable_automation after a parameter was moved by hand or by set_device_params.

Inputs: action (required), slot, scene, track, +2 more.

undoA

Undo or redo one step in Live, like Cmd+Z. Every Tonable change is one step (a batch too). Live's undo history is shared with everyone working in the Set, so read the state afterwards to see what changed.

Inputs: action.

update_clipA
Destructive

Change a clip's settings and optionally run an action; every field you leave empty stays as it is. Works on Session and timeline clips, MIDI and audio.

Settings: name, color, mute, loop and marker positions, time signature, launch mode and quantization, legato, clip scale, groove; for audio also warping, warp mode, gain, pitch and RAM mode. Actions: fire, stop, crop to the loop, duplicate_loop, quantize (grid, amount), clear_envelopes, move_playing_position, and warp markers (add, move, remove). Each field gets a result line with what Live holds afterwards; Live keeps the old value for something it refuses and the line says so. Loop markers that Live refuses in one order are tried again after the others. One undo step.

Inputs: clip, gain, grid, name, +29 more.

update_deviceA

Turn a device on or off, rename it, move it to another track or chain, set a rack's visible macros, store or recall a macro variation, or mute and solo a rack chain or Drum Rack pad. Only given fields change. One undo step.

Inputs: target (required), on, mute, name, +5 more.

update_setA

Change the Set's tempo, time signature, Arrangement loop, metronome, key, recording state (record, overdub, session record, punch, quantization), groove amount, Link and track-arming rules.

Only the fields you give change; the answer shows the Set's state afterwards, with one result line for each recording or behavior field (Live keeps the old value for a setting it refuses, and the line says so). One undo step.

Inputs: link, loop, scale, tempo, +20 more.

update_trackA

Change a track's name, color, volume, pan (or split-stereo pans), sends, mute, solo, arm, monitoring, crossfader assignment, group folding or routing (input and output, with channels). On the master it also sets the cue volume and crossfader.

Only the fields you give change, each with its own result line ("now" shows what Live displays afterwards; a field that fails says why and the others still apply). Works for return tracks (rA) and the master (m). One undo step.

Inputs: track (required), arm, pan, mute, +18 more.

write_clipA
Destructive

Create a MIDI clip in a Session slot, or change one (also a timeline clip, clip t0/a1), and write its notes.

An empty slot gets a new clip. mode=replace (default) leaves exactly the given notes in the clip; mode=add keeps the existing ones. All of it is one undo step. Notes that fail a check come back in "rejected" with the reason; the rest are written. Works on MIDI tracks only; read_set shows the tracks and scenes. Notes may carry probability, velocity_deviation and release_velocity.

Inputs: clip, mode, name, slot, +3 more.

write_envelopeA
DestructiveIdempotent

Replace one parameter's automation in a Session clip with these points, or clear it with no points. Values ramp from point to point unless a point has jump=true. Works for the mixer (volume, pan, sends) and device parameters, including rack macros; MIDI CC is not reachable (use CC Control's Custom A, CC 64 Sustain, for the pedal). Copy the clip to the Arrangement to keep the automation there. One undo step.

Inputs: slot (required), track (required), parameter (required), points.

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

Loading tool schema changelog…

    TDQS

    A3.6/5.0

    Scored across 31 tools

    Disambiguation3/5

    Many tools share the clip/device/set editing space: update_clip vs write_clip vs edit_notes, update_device vs set_device_params vs configure_device, and generic duplicate/delete vs scene/arrangement-specific actions. Descriptions mostly explain the intended split, but the overlap requires careful reading and creates real misselection risk.

    Naming Consistency3/5

    Names are consistently snake_case and mostly verb_noun (read_track, update_clip, create_track), but a significant minority are bare nouns/namespaces (app, scene, groove, transport, arrangement) or generic verbs (duplicate, delete, undo). The mix is readable but not a single predictable convention.

    Tool Count3/5

    31 tools is heavy for an MCP surface, and some adjacent CRUD/update tools could be consolidated. However the Ableton Live domain is broad, and several noun-namespace tools bundle many sub-actions, so the count is defensible rather than arbitrary.

    Completeness4/5

    Coverage spans set/track/clip/device/scene/arrangement/transport/browser/automation/groove with an explicit live_api fallback, so core lifecycle operations are present. Some gaps remain (Arrangement automation readback, MIDI CC, groove creation/deletion), though most are Live API limitations with documented workarounds.

    Maintenance

    ActivityMaintained
    ResponsivenessNo recent community issues

    Related MCP Connectors

    Related MCP Servers

    • A
      license
      B
      quality
      D
      maintenance
      Connects Claude AI to Ableton Live via the Model Context Protocol, enabling prompt-assisted music production, track and clip manipulation, and session control.
      16
      MIT
    • A
      license
      Not graded
      quality
      C
      maintenance
      Connects AI clients to Ableton Live 12, enabling deep control and editing of live sets, sound search, listening/evaluation, and version exploration through MCP tools.
      616 npm
      Business Source 1.1
    • A
      license
      B
      quality
      C
      maintenance
      Enables AI assistants to control Ableton Live through MCP, allowing MIDI writing, audio import, device parameter adjustment, clip arrangement, and playback control over a localhost-only connection.
      37
      MIT