This server exposes an MCP interface to Ableton Live 12 via OSC, enabling an AI assistant to observe and control a Live session. Capabilities include:
Reading session state: Get session overview (tempo, time signature, track summaries), track details (devices, clip slots, routing), MIDI clip notes, transport state (playing, beat position, loop), and currently selected objects.
Analyzing musical content: Detect key/scale at clip, track, or session level.
Writing musical ideas: Create MIDI clips with notes, modify existing clip notes, generate chord progressions, and drum patterns.
Controlling transport & song settings: Set tempo (BPM) and time signature; capture MIDI.
Managing tracks, clips, and scenes: Create, duplicate, delete, rename, and color tracks, clips, and scenes.
Triggering playback: Fire or stop specific clips.
Controlling devices: Load devices from Live's library, set device parameters, and manage clip automation.
Mixing: Adjust track volume, panning, mute, solo, and arm.
Browsing the library: List browser contents and load instruments/effects.
Undoing actions: Perform undo operations.
Utility: Look up Ableton Live keyboard shortcuts by action name.
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-mcp Give me an overview of my current Ableton session."
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.
An MCP server that lets Claude observe and compose in Ableton Live 12 via AbletonOSC.
Designed for musicians who want a pair-programming-style collaborator: Claude can read your Live set, explain what's there, and write musical ideas directly into clips — then narrate the choices so you learn as you go.
v0.8 — high-level composition tools and a simpler write API. create_chord_progression (roman numerals or chord names + key) and create_drum_pattern (step strings like x...x...x...x...) let Claude express harmonic and rhythmic ideas in a few tokens instead of emitting raw note lists. The duplicate/delete/rename trio per object collapses into one edit_track / edit_clip / edit_scene tool each, cutting the surface area Claude has to reason about. Browser listing in the forked AbletonOSC now caches per-folder results, so the first hit pays the disk walk and subsequent list_browser calls return instantly (previously they tripped the 2.0s OSC timeout on large libraries). v0.7 added analyze tools (detect_clip_key, detect_track_key, detect_session_key) using Krumhansl-Schmuckler key profiles. Builds on v0.6 scenes + color, v0.5 revise-and-respond (undo, capture MIDI), v0.4 automation, and v0.3 browser/loading.
Related MCP server: Ableton MCP
Claude ←→ MCP (this repo, stdio) ←→ python-osc ←→ AbletonOSC remote script ←→ Ableton Live 12Read — get_session_overview, get_track_detail, get_clip_notes, get_transport_state, get_selected, get_device_parameters, list_browser, sample_clip_automation
Analyze — detect_clip_key, detect_track_key, detect_session_key
Revise — undo
Write — create_midi_clip, modify_clip_notes, create_chord_progression, create_drum_pattern, set_tempo, set_time_signature, create_track, load_device, set_device_parameter, set_clip_automation / clear_clip_automation, set_track_volume / set_track_panning / set_track_mute / set_track_solo / set_track_arm, edit_track / edit_clip / edit_scene (duplicate, delete, rename), create_scene, set_clip_color / set_scene_color, capture_midi, fire_clip / fire_scene / stop_clip (gated — Claude must ask the user)
This repo bundles a forked AbletonOSC as a submodule with a BrowserHandler added for list_browser / load_device. Clone with submodules and symlink into Live's MIDI Remote Scripts folder:
git clone --recurse-submodules https://github.com/mrinalghosh/ableton-mcp.git
cd ableton-mcp
# macOS
ln -s "$PWD/AbletonOSC" "$HOME/Music/Ableton/User Library/Remote Scripts/AbletonOSC"macOS: ~/Music/Ableton/User Library/Remote Scripts/
Windows: Documents\Ableton\User Library\Remote Scripts\
Then in Live → Settings → Link, Tempo & MIDI, add AbletonOSC as a Control Surface.
git clone https://github.com/mrinalghosh/ableton-mcp.git
cd ableton-mcp
pip install -e .Add to your Claude Code / Claude Desktop MCP config:
{
"mcpServers": {
"ableton": {
"command": "ableton-mcp"
}
}
}The system prompt asks Claude to write first, then explain: when you ask for a musical idea, Claude generates the MIDI directly into Live, then narrates the choices (key, rhythm, voice leading). When you ask "what is this?", Claude grounds itself with get_selected before answering.
Track/clip names come back with hyphens instead of spaces. AbletonOSC normalizes whitespace in string responses, so a track displayed in Live as 1 MIDI is reported as 1-MIDI. We pass this through unchanged — reversing it would corrupt names the user actually wrote with hyphens.
undo is per-Live-action, not per-MCP-tool. A single MCP write may correspond to several Live undo steps (e.g. create_track + load_device + create_midi_clip is three undos), or to one (a modify_clip_notes with 16 notes is one). To fully reverse a multi-step change, call undo repeatedly — the reply's can_undo_more flag indicates whether more history remains. AbletonOSC doesn't expose undo grouping, so we can't fix this in the wrapper.
v0.1: end-to-end smoke test against real Live instance; name tracks after creation
v0.2: device parameter control (get_device_parameters, set_device_parameter); per-track mixer (volume, pan, mute, solo)
v0.3: browse Live's Library and load instruments/effects onto tracks (forked AbletonOSC adds BrowserHandler)
v0.4: clip automation lanes — read/write parameter envelopes inside a clip (forked AbletonOSC adds AutomationHandler)
v0.5: revise-and-respond — undo; duplicate_clip / delete_clip / delete_track / rename_track / rename_clip; capture MIDI (record-arm + Capture) so Claude can riff on what you just played
v0.6: scene management (create_scene, fire_scene, delete_scene, rename_scene); clip color so Claude can visually group variants
v0.7: scale/key inference — detect_clip_key / detect_track_key / detect_session_key using Krumhansl-Schmuckler key profiles, plus pitch utility helpers
v0.8: high-level composition tools (create_chord_progression, create_drum_pattern) so Claude can express musical ideas in a few tokens; collapse per-object dup/delete/rename into single edit_track / edit_clip / edit_scene tools; cache browser folder listings in AbletonOSC fork to fix list_browser timeouts on large libraries
v0.9: quantize captured MIDI — close the capture loop with quantize_clip
MIT — see LICENSE.
Create a MIDI clip and fill with notes. Use this when the user wants a musical idea written into the set.
| Name | Required | Description | Default |
|---|---|---|---|
| track | Yes | ||
| clip_slot | Yes | ||
| length_beats | Yes | ||
| notes | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are present, so the description must disclose behavior. It mentions creating and filling but does not explain whether it overwrites existing clips, what happens if the slot is occupied, or any side effects like selection changes.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is very concise with two sentences and no redundant information. It could be improved by adding more detail without becoming verbose.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given 4 required parameters, no output schema, and no annotations, the description lacks essential details. It does not explain the note object structure, constraints on clip_slot, or length_beats format, making it incomplete for reliable use.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has 0% description coverage, yet the description only adds 'fill with notes' to explain the notes parameter. It does not clarify the meaning of track or clip_slot, nor the structure of note objects, leaving significant ambiguity.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool creates a MIDI clip and fills it with notes. This distinguishes it from sibling tools like fire_clip or modify_clip_notes, as it focuses on creation with content.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description says to use it when the user wants a musical idea written into the set, providing some context. However, it does not explicitly contrast with alternatives like modify_clip_notes or specify when not to use it.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Create a new MIDI or audio track at end of set.
| Name | Required | Description | Default |
|---|---|---|---|
| track_type | No | midi | |
| name | No |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Without annotations, the description must disclose behavioral traits. It only states 'Create' but does not mention any side effects, required permissions, or constraints beyond schema defaults.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single short sentence, which is concise but under-specified for the tool's complexity. It omits critical information, making it insufficient despite its brevity.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a tool with 2 parameters and no output schema or annotations, the description is incomplete. It does not explain return values, error conditions, or the behavior of default parameters.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
With 0% schema description coverage, the description adds no meaning to the parameters beyond their names and defaults. It fails to explain valid values for track_type or the effect of name being null.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action (create) and the resource (a new MIDI or audio track) with placement (at end of set). It is specific and distinguishes the basic operation from sibling tools like create_midi_clip.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is provided on when to use this tool versus alternatives, such as when to create a track vs a clip. There is no mention of prerequisites or conditions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Look up an Ableton Live keyboard shortcut by action name.
| Name | Required | Description | Default |
|---|---|---|---|
| action | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided. Description only says 'look up', which implies read-only, but does not disclose behavior on missing action, side effects, or permissions. Minimal transparency.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Single sentence, directly states purpose, no wasted words. Front-loaded and efficient.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Low complexity (1 param, no output schema). But description omits what the tool returns (e.g., key combination, description). Incomplete for a lookup tool.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema has 0% coverage. Description adds meaning by stating the parameter is an 'action name', but no format, examples, or constraints are given. Partial compensation.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
Description uses specific verb 'look up' and resource 'keyboard shortcut', and input 'action name'. Clearly distinguishes from sibling tools which are creation/manipulation.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Implies usage for looking up shortcuts by action name, but no explicit when-to-use, when-not-to-use, or alternatives. Context is clear but no guidance.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Start playing a clip. ASK THE USER FIRST before calling — surprise playback is disruptive.
| Name | Required | Description | Default |
|---|---|---|---|
| track | Yes | ||
| clip | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden. It warns that surprise playback is disruptive, which is a crucial behavioral trait. However, it does not disclose what happens if the clip is already playing or if parameters are invalid.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two sentences, no unnecessary words. The purpose is front-loaded, followed by a critical usage guideline. Highly efficient.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given no annotations or output schema, the description covers the essential purpose and a key behavioral note but omits parameter details and behavior beyond the warning. Adequate for a simple trigger, but not comprehensive.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema has 0% description coverage, and the description does not explain the meaning or required format of 'track' and 'clip' parameters. The agent must infer from parameter names alone.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb 'Start playing' and the resource 'clip', making the action unambiguous. It distinguishes this tool from siblings like 'stop_clip'.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Explicitly instructs the agent to ask the user first before calling, preventing disruptive surprise playback. This is a strong, actionable guideline.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
MIDI notes in a clip: pitch, start (beats), duration, velocity.
| Name | Required | Description | Default |
|---|---|---|---|
| track | Yes | ||
| clip | Yes |
| Name | Required | Description |
|---|---|---|
| result | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The description partially discloses behavior by listing the returned fields, but does not state side effects (e.g., read-only), preconditions (e.g., clip must contain notes), or error conditions. Given no annotations, the description carries the full burden but is only adequate.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, short sentence (8 words) that immediately conveys the core purpose. It is front-loaded and to the point.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the presence of an output schema, the description does not need to fully explain return values, but it still lacks context about parameter usage (e.g., zero-indexing, track/clip numbering). The tool is simple but missing basic contextual details.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema has 0% description coverage, and the description does not add any meaning to the parameters 'track' and 'clip'. It only describes the output, leaving parameter semantics completely unexplained.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool returns MIDI notes attributes (pitch, start, duration, velocity) from a clip. It implies a read operation and differentiates from sibling modify_clip_notes. However, it could be more explicit with a verb like 'retrieve'.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is provided on when to use this tool versus alternatives like modify_clip_notes or get_track_detail. There is no mention of prerequisites or context for using this tool.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
What the user currently has selected in Live. Call this first when the user asks 'what is this?'.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
| Name | Required | Description |
|---|---|---|
No output parameters | ||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided. Description lacks details on edge cases (e.g., nothing selected), read-only guarantee, or output format beyond mentioning selection. More behavioral context needed.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two concise sentences, front-loaded with purpose. No unnecessary words.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given no parameters and the presence of an output schema, the description is adequate. It could clarify the scope of 'selected' but return values are covered by schema.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
No parameters exist; schema coverage is 100%. Description adds meaning by explaining the tool's purpose, which is valuable and meets the baseline for zero parameters.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
Description clearly states that the tool returns the current selection in Live, with a specific use case ('Call this first when the user asks "what is this?"'). It distinguishes from sibling tools that create or modify.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Provides explicit guidance on when to invoke ('call this first'). Does not mention alternatives or when not to use, but given the context it's clear this is the primary selection inquiry tool.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Tempo, time signature, and summary of every track.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
| Name | Required | Description |
|---|---|---|
No output parameters | ||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description only states the output (tempo, time signature, summary) but does not disclose behavioral traits like whether it is a live fetch, expensive, or read-only. No contradictions with annotations (none provided).
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Single sentence, concise and front-loaded. Every word earns its place with no redundancy.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool has no parameters and an output schema exists (not shown), the description is adequate for a simple overview tool. It lists the three returned aspects, but could be slightly more specific about 'summary of every track'.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has no parameters, so description coverage is 100% by default. The description adds no parameter info because there are none to document. Baseline for 0 parameters is 4, and no extra value is needed.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool returns tempo, time signature, and a summary of every track, aligning with the tool's name. However, it lacks a verb like 'get' or 'retrieve', but the name implies the action. It distinguishes from siblings like get_track_detail and get_transport_state.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance on when to use this tool versus alternatives, such as get_track_detail for individual track info or get_transport_state for transport state. The description provides no context on prerequisites or common use cases.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Devices, clip slots, and routing for one track.
| Name | Required | Description | Default |
|---|---|---|---|
| track | Yes |
| Name | Required | Description |
|---|---|---|
No output parameters | ||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description must fully disclose behavioral traits. It mentions the tool returns devices, clip slots, and routing, which is helpful, but it omits whether this is a read-only operation, any authorization requirements, or side effects. For a data retrieval tool, the absence of a read-only hint leaves uncertainty.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single sentence that is appropriately sized and front-loaded. Every word serves a purpose with no redundant content.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's simplicity (one integer parameter) and the existence of an output schema (so return values need not be described), the description is minimally adequate. However, it lacks details on parameter semantics and behavioral traits, leaving some ambiguity. Overall, it meets the bare minimum but has clear gaps.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has one parameter 'track' with 0% description coverage. The description adds no meaning beyond the schema's title 'Track'; it does not clarify whether the value is an index or name, or provide any format or constraints. With low schema coverage, the description should compensate but fails to do so.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description 'Devices, clip slots, and routing for one track' clearly states what the tool retrieves (devices, clip slots, routing) and for which resource (one track). It uses specific nouns and verb (implied get), distinguishing it from sibling tools like create_track or fire_clip.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance on when to use this tool versus alternatives. While the purpose implies it's the only get-detail tool for a track, there is no explicit statement about when not to use it or mention of sibling tools like get_selected that might serve a similar purpose. The description lacks context for selection.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Transport state: playing, current beat, loop.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
| Name | Required | Description |
|---|---|---|
No output parameters | ||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations exist, so description must carry burden. It lists returned components (playing, beat, loop) but does not mention safety, side effects, or that it is a read-only operation. Partially transparent.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Single sentence, no waste, but could be front-loaded with an action verb like 'Get' for clarity. Acceptable conciseness.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given no parameters and an output schema, description lists key state components. Adequate for a simple state query tool.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Input schema has no parameters and coverage is 100%. Description adds no param info, but baseline is 4 due to schema richness.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
Description states the tool returns transport state including playing, current beat, and loop. It is clear but does not differentiate from sibling tools. Could be more specific, e.g., 'Get the current transport state.'
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance on when to use this tool vs alternatives. Sibling tools like fire_clip, get_track_detail exist but no comparison provided.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Replace all notes in an existing MIDI clip.
| Name | Required | Description | Default |
|---|---|---|---|
| track | Yes | ||
| clip | Yes | ||
| notes | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided, so description must disclose behavioral traits. It only says 'replace all notes,' but does not mention side effects (e.g., whether it preserves clip length), required permissions, or if the clip must be stopped first.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
One sentence, concise and front-loaded with the verb 'replace.' It could add a bit more detail without becoming verbose, but it is efficient.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a tool with 3 required parameters, no output schema, and no annotations, the description is inadequate. It does not specify the format of the notes array or any constraints, making it hard to use correctly.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, and the description adds no meaning beyond the schema. The track, clip, and notes parameters are not explained; notes is an array of objects with no format details.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action and resource: 'Replace all notes in an existing MIDI clip.' It distinguishes from sibling tools like get_clip_notes (retrieve) and create_midi_clip (create).
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance on when to use this tool versus alternatives. It does not mention when not to use or compare with other tools like get_clip_notes or create_midi_clip.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Set song tempo (BPM).
| Name | Required | Description | Default |
|---|---|---|---|
| bpm | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided; the description only says 'Set' implying mutation but does not disclose behavioral traits like reversibility, effect on playback, or authorization requirements.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is very concise (one sentence) but lacks any structural separation for parameter details. It earns its place but could be expanded without losing conciseness.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The tool has one parameter and no output schema; the description should explain expected behavior (e.g., immediate effect on playback, return value) but only states the purpose.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, requiring the description to compensate. It only restates the parameter name ('BPM') adds no additional meaning like valid range, suggested values, or format.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states verb 'Set' and resource 'song tempo' with unit 'BPM'. It distinguishes from sibling tools like set_time_signature, but could be more specific about scope (global vs per-track).
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance on when or when not to use this tool. There are no alternative tempo tools provided, so the description should at least imply typical usage scenarios.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Set song time signature.
| Name | Required | Description | Default |
|---|---|---|---|
| numerator | Yes | ||
| denominator | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description must carry the burden. It does not disclose any behavioral traits such as whether the change is global, affects existing clips, or is undoable.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single concise sentence with no wasted words, but it could benefit from a bit more structure to include parameter details.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given no output schema and minimal description, the agent lacks critical information like valid ranges for parameters or the effect of setting the time signature, making the tool definition incomplete.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has 0% description coverage, and the description does not explain what numerator and denominator represent, leaving the agent to infer their meaning.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action (set) and the resource (song time signature), which is specific and distinct from sibling tools like set_tempo.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance on when to use this tool vs alternatives, or any prerequisites. The description lacks context for appropriate usage.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Stop a clip.
| Name | Required | Description | Default |
|---|---|---|---|
| track | Yes | ||
| clip | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description must disclose behavioral traits. It only states 'Stop a clip' but does not explain what happens if the clip is not playing, if it affects other clips, or if there are any side effects (e.g., resetting position).
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
While extremely concise, the description is under-specified and fails to provide essential context. Conciseness should not come at the expense of clarity or completeness.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given no annotations, no output schema, and only 2 parameters, the description should at minimum explain the parameters and return value. It provides none of this, making it insufficient for reliable tool selection and invocation.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has 2 parameters (track, clip) with 0% description coverage. The description adds no meaning beyond the schema, leaving the agent to guess what integer values represent (e.g., track index, clip index).
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action (stop) and the resource (a clip). It is a specific verb+resource combination, but it does not distinguish between different types of clips (e.g., audio vs. MIDI) or contrast with sibling tools like fire_clip.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is provided on when to use this tool vs. alternatives like fire_clip, or what prerequisites are needed (e.g., the clip must be playing). The agent receives no context for appropriate invocation.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
v0.0.0create_midi_clipcreate_trackexplain_shortcutfire_clipget_clip_notesget_selectedget_session_overviewget_track_detailget_transport_statemodify_clip_notesset_temposet_time_signaturestop_clipScored across 13 tools
Each tool targets a distinct action or resource: clip creation/modification, transport controls, track management, session overview, and shortcut lookup. No two tools have overlapping purposes.
All tools follow a consistent snake_case verb_noun pattern (e.g., create_midi_clip, get_clip_notes, set_tempo), making them predictable and easy to distinguish.
13 tools cover the essential operations for an Ableton Live assistant without being overwhelming. The scope is well-balanced for core music production tasks.
Covers clip, track, transport, and session management. Missing operations like delete_track or record_arm are minor gaps that agents can work around, but core workflows are solid.
Generate AI music via the Lacuna Music API from MCP clients like Claude Desktop & Code.
Create, co-edit, analyze, publish, and export collaborative step-sequencer sessions through MCP.
Claude Code / MCP skills for the dev pipeline: discover, spec, design, build, ship, operate.
Use AI models for chat, image, and video generation from Claude Code and other MCP hosts.
