Features

Producer Pal is an Ableton MCP server that lets any AI read, create, and modify your Live Set. Tell the AI what you want and it uses more than 20 tools to work with tracks, clips, devices, and the arrangement.

It works with virtually any AI, including its built-in Chat UI, desktop apps like Claude Desktop and ChatGPT, CLI tools, and web apps. Coding agents can use the portable Agent Skill instead of MCP, and the REST API exposes the same tools over plain HTTP with no AI in the loop.

Get started →

What It Can Do

• Tracks and mixing: add MIDI, audio, and return tracks; set gain, pan, sends, routing, monitoring, mute/solo/arm, names, and colors. Track tools →
• MIDI clips: write and edit notes in a text notation built for language models, with velocity ranges, probability, and complex rhythms, then reshape them with transforms. Clip tools →
• Audio clips: place samples, set gain, pitch shift, and warp settings, reshape the region, and arrange them on the timeline. Producer Pal manages audio but can't listen to it; see Limitations. Clip tools →
• Arrangement: place, move, split, and duplicate clips along the timeline, add locators, and stack alternate versions on take lanes. Clip tools →
• Session view: create scenes, capture what's playing into a new one, and give a scene its own tempo and time signature. Scene tools →
• Devices and instruments: add and control native Live instruments and effects, build Drum Racks and Simpler instruments from samples, move devices into racks, and drive macro variations. Third-party VST/AU plug-ins need a mapping step first; see Limitations. Device tools →
• Library: search Live's browser by name or tag, browse its category taxonomy, rank samples by similarity to a seed sample, and list installed plug-ins (Live 12.4+). Your own sample folder is searched by name. Library →
• Playback: start and stop Session or Arrangement playback, launch clips and scenes, set loop points, and jump to locators. Playback →
• Project settings and overview: read every track and scene in one call, with a clip count per track; change tempo, time signature, and scale. Live Set tools →
• Context & memory: project notes, global preferences, and memory the AI builds as you work. Context & Memory →

Every tool, with its full parameter list: Tool Reference →

What it can't do (automation, VST/AU plug-in internals, audio analysis): Limitations →

MIDI Notation

Producer Pal gives the AI a text-based music notation to compose in, rather than raw MIDI note data, so it can translate "bar 3, beat 2" into the right position in a clip or on the arrangement timeline. Used by Create Clip, Update Clip, and Read Clip.

Three notations are available. The device setting picks the default, and a client can override it per request:

• bar|beat: the default. Compact and expressive: pitches are names (C3, F#4), time is bar|beat (1|1, 2|3), durations are note values (n/4, n/8), plus velocity ranges, probability, and bar copying.
• MIDI JSON: notes as a compact JSON array. The most exact, and the easiest for coding agents to generate and parse.
• Stark: a literal, round-trippable notation with chord symbols and event-based drum lines, friendly to small and local models.

Read the full notation guide →

Transforms

Apply complex changes to clips using math expressions via Create Clip, Update Clip, and Duplicate. Transforms work the same way in every notation. When updating or duplicating multiple clips at once, one transform string broadcasts across every clip/copy. Use clip.index arithmetic or clipseq() inside the string for per-clip variation:

• Transform MIDI notes: velocity, pitch, timing, duration, probability
• Transform audio clips: gain, pitch shift
• Shapes: LFO waveforms (sin, cos, tri, saw, square), ramps, curves, randomization with arbitrary ranges, choose from sets of values (e.g. chord notes)
• Context variables: Access note order (note.index), clip metadata (clip.duration, clip.index, clip.position) in expressions
• Selectors: Target specific pitch ranges (e.g., C3:, C3-C5:) or time ranges (e.g., 1|1-2|4:), or both in either order (e.g., C3 1|1-2|4: or 1|1-2|4 C3:)

Read the full transforms guide →

Paths

Everything in your Live Set has a short address, counting from 0: t2 is the third track, t2/s3 a clip slot, s3 a scene, rt0 the first return track, mt the main track, t1/d0 a device, and t1/d0/pC1 a Drum Rack pad. Reads report a path next to every id and the write tools accept one, so the AI can act on what it just read instead of looking it up again.

An arrangement clip is addressed by a position on the timeline: t0[5|1] is the clip playing at bar 5 on track 0, even if it started earlier, and t0/l1[5|1] the one on its second take lane. A position can name a locator rather than counting bars, t0[loc:Chorus], which still lands right after you move that section.

A + names a place that doesn't exist yet, for creating or moving: t+ appends a track, s+ a scene, rt+ a return track, and deeper in a path t0/d+ a device, t0/d0/c+ a rack chain, and t0/l+ a take lane.

A device can also be named by kind: t0/inst is the track's instrument wherever it sits, and t0/afx0 / t0/mfx0 its first audio / MIDI effect.

Take Lanes

Live's take lanes stack alternate versions of an arrangement clip at the same position, and only the active take plays, so you can audition variations without cluttering the timeline.

• A lane is part of the path: t2/l0 is track 2's first take lane (0-based, and lanes are created up to the index). Plain t2 is the main lane. Use it as path on Create Clip or toPath on Duplicate.
• Naming one lane twice stacks both copies on it, so toPath: "t2/l0[9|1],t2/l0[13|1]" puts two takes on one lane. A lane per copy is a lane index per copy, toPath: "t2/l0,t2/l1,t2/l2". On a track that already has lanes, start after the last one a prior Read Track reported. Add transforms to vary each one.
• A whole lane goes onto another lane in a single Duplicate: type: "track" with toPath: "t2/l0" copies every clip at the position it already has, clips only, and the two tracks must match MIDI/audio type. The source is a track (path: "t2", its main lane) or a take lane (path: "t2/l0", or the lane's id).
• A take lane goes the other way too: give a take-lane source a bare track toPath (t2, its own track or another) and its clips are promoted onto that track's main lane, replacing whatever sits at those positions.
• Update Track owns the lanes themselves: path: "t2/l+" adds one, path: "t2/l0" with a name names an existing one, and a lane takes no other track setting.
• Read Track lists take lanes (with the arrangement-clips include), and reads one on its own from a lane path.
• A take-lane clip can leave its lane, for another lane, another track, or a session slot: toPath on Update Clip moves it, and Duplicate copies it. Live's API can't remove a take-lane clip, so a move leaves a muted (moved) ... clip behind for you to delete in Live.
• Putting a clip on a lane, or taking one off, re-creates it: a MIDI clip from its notes, an audio clip from its sample. Envelope automation isn't preserved, and a warped audio clip comes back with the sample's default warp markers. The response says which applied.
• Limits: Producer Pal creates up to 10 take lanes per track; lanes added in Live past that still work. A take-lane clip can't be split, resized, or deleted through tools, and Producer Pal can't pick the active take or comp lanes. All of that stays in Live's UI. Expand the take-lane arrow on a track header to see them.

Network Control

Control Ableton Live from another computer on your local network, no extra setup required. For fully remote control, use web tunnels.

Small Model Mode

Adapts Producer Pal for less capable AI models by returning simplified skills and removing advanced parameters from tool schemas. This is an ongoing R&D effort aimed at making local models viable for completely offline, free, and private usage. Enable it on the device's Setup tab, in the Chat UI settings, or via the --small-model-mode flag. Like notation, that's a global default MCP clients pick up too, and a single client can override it per request. It's also the biggest reduction in what a conversation costs; see Optimizing for the trade-off.

Choosing a Toolset

You don't have to run every tool. Withholding one drops its schema and the part of the skills that teaches it, so a narrower toolset makes every conversation cheaper: read-only alone cuts the schemas and skills by 62%. Worth doing if you only ever use part of Producer Pal, or if you're running a small/local model that does better with a short tool list. See Optimizing for the numbers and the other levers.

Counting the tools

There are 21 tools on by default. Two more are experimental and opt-in: Direct Live API and Subagent. The Chat UI counts all 23, so it reads 21/23 out of the box. An MCP client sees 21 because Subagent is client-side and never appears in listTools, and Direct Live API is only registered when the device flag is on (which makes it 22).

Where you set it depends on the client:

• Chat UI: the Tools tab, per conversation and per preset.
• MCP clients via npx producer-pal: the --tools and --disable-tools flags. Run npx producer-pal@latest --list-tools for the group names and the tools your device currently offers.
• Claude Desktop: the extension's Tools and Disable tools settings.
• REST API: the x-producer-pal-disabled-tools header, per request. This is also what the Agent Skill's --disable-tools flag sends.

All of these are per client, so narrowing one client's toolset leaves the Chat UI and everything else alone, as do the notation and small-model-mode headers that travel with it. Each of the clients above keeps ppal-connect, since it is how the AI connects and receives the skills. Only the raw header lets you drop it.

Subagents

In the Chat UI, AI can hand a self-contained task to a nested assistant working in the same Live Set: plan a track's arrangement, then delegate each part and check the results. Independent tasks run in parallel, and a subagent can be given follow-up work rather than replaced by a fresh one.

The point is cost and context as much as speed: a worker's transcript never enters the main conversation, only its final answer, and each worker can run a cheaper model with a narrower toolset than the assistant directing it. That pairing is what presets are for: a named bundle of provider, model, tool set, and notation, with one designated as what subagents run as. This is experimental and off by default.

Set up subagents →

Skills

The Connect tool returns a skill set that teaches the AI how to use Producer Pal's notation, transforms, device paths, and other conventions. It's sent to external MCP clients in the ppal-connect result and used by the built-in Chat UI on every conversation.

The exact text depends on the active notation and on small model mode, six combinations in all, so rather than reproduce them here:

• Read them in the Chat UI's Skills tab → Preview, which assembles the whole document for any notation and model size, with your own overrides applied. A ★ marks the combination your current settings use, and a size readout shows what it costs you per conversation.
• Change them: every fragment can be overridden or dropped. See Customizing Skills.
• Browse the source in src/skills/ on GitHub.

Agent Skill (for coding agents)

Not to be confused with the skills above: an Agent Skill is the portable SKILL.md convention that Claude Code, Codex CLI, and Gemini CLI share. Producer Pal ships one: a drop-in folder that drives the REST API, so a coding agent can control Ableton Live with no MCP client at all.

It stays a thin bootstrap rather than a copy of the guidance: it tells the agent to call ppal-connect first, which returns the same skill set described above. New tools and skill updates land in that response automatically, so the SKILL.md never needs to change.

Set up the Agent Skill →