Tonable
Server Configuration
Describes the environment variables required to run the server.
| Name | Required | Description | Default |
|---|---|---|---|
No arguments | |||
Instructions
Guidance the server publishes about itself, which clients place ahead of the tool catalog so the model reads it before choosing anything.
Tonable controls Ableton Live 12 on this computer through a Remote Script inside Live. Call live_status first: it says whether Live is connected and what Set is open. Addresses: t0 is the first track (numbers from 0), rA return track A, m the master. Devices: t0/d0 first device; inside racks t0/d0/c1/d0 (chain 1, device 0); Drum Rack pads t0/d0/pC1 (note names with C3 = MIDI 60). Clips: t0/s2 is the Session clip in slot 2 of t0, t0/a1 the second timeline clip. Times are in beats (quarter notes) unless a field says bars. Every write is read back: a result line with "error" means Live kept the old value. Use the dedicated tools first; live_api reaches the rest of Live's object model. Read before you change anything, and quote the address and name to the user. If a call fails with code not_running, tell the user to choose Tonable in Live's Settings -> Link, Tempo & MIDI -> Control Surface. A timeout_not_started error means nothing changed. timeout_running or connection_lost means the command may still have run: read the state before repeating it.
Capabilities
Features and capabilities supported by this server
Protocol revision2025-11-25
| Capability | Details |
|---|---|
| tools | {
"listChanged": false
} |
| prompts | {
"listChanged": false
} |
| resources | {
"subscribe": false,
"listChanged": false
} |
| experimental | {} |
Tools
Functions exposed to the LLM to take actions
| Name | Description |
|---|---|
| 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. |
| read_clipA | 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. |
| write_clipA | 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. |
| edit_notesA | 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. |
| arrangementA | 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. |
| batchA | 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. |
| update_clipA | 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. |
| 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. |
| 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. |
| read_deviceA | 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. |
| set_device_paramsA | 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. |
| 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. |
| find_in_libraryA | 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. |
| load_deviceA | 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. |
| inspect_preset_fileA | 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. |
| read_envelopeA | 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. |
| write_envelopeA | 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. |
| grooveA | 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. |
| live_apiA | 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. |
| live_statusA | 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. |
| read_setA | 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. |
| 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. |
| 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. |
| 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. |
| 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. |
| configure_deviceA | 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. |
| read_trackA | 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. |
| 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. |
| 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. |
| deleteA | 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. |
| 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. |
Prompts
Interactive templates invoked by user choice
| Name | Description |
|---|---|
No prompts | |
Resources
Contextual data attached and managed by the client
| Name | Description |
|---|---|
No resources | |
TDQS
Scored across 31 tools
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.
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.
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.
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.