Skip to main content
Glama

Logic Pro MCP

An MCP server that lets AI agents (Claude Code, Claude Desktop, Hermes, Cursor, any MCP client) drive Logic Pro on macOS — transport, tracks, mixer, plug-ins, bounce, delivery — with every result read back from Logic, plus hands-and-voice control of the faders. Works with both the desktop purchase and the Creator Studio subscription build (com.apple.mobilelogic). Package name logic-pro-mcp; the Python module is logic_mcp.

Not affiliated with or endorsed by Apple. Logic Pro is a trademark of Apple Inc.

Apple ships no API, so this talks to Logic the way hardware does:

Channel

What it does

Readback

OSC (a fake TouchOSC control surface)

mixer strips, pan, selection, transport, plug-in parameters, Channel EQ — the best path for anything with a value

Logic echoes its own state back

MCU (Mackie Control emulation over virtual CoreMIDI)

transport, and per-strip mute/solo/arm/select/faders for the eight tracks Logic currently shows on the surface

LED echo, LCD text, fader echo

Accessibility

control bar (Play/Record/Cycle/Count In, tempo, playhead), track headers, dialogs

live UI values

CGEvent key commands

anything with a shortcut (new track, save, undo, editors)

via AX

AppleScript

launch / activate / open / quit

–

Logic Pro Virtual In MIDI

notes, chords, sequences, CC, program, pitch bend, SysEx, MMC

–

Zero manual setup in Logic: Logic auto-scans new MIDI ports with Mackie Control device queries, we answer the handshake, and Logic installs the surface itself. Endpoints carry fixed CoreMIDI unique IDs so the binding survives restarts.

Install

Requires a local Mac with Logic Pro. Linux containers, including Glama's hosted Docker build environment, cannot run the CoreMIDI, Accessibility, and PyObjC integrations. The Glama directory listing is for discovery; it is not a hosted Logic Pro service. Use the local doctor command below to check your Mac's setup.

Directory inspection (Linux/CI)

LOGIC_MCP_INSPECT_ONLY=1 uv run logic-pro-mcp exposes the same tool and resource schemas without importing any DAW backends. Every tool call and resource read returns an explicit error in this mode, including health checks. It does not simulate a connected Mac or provide remote control. Never enable this variable in your normal Logic Pro client configuration.

For Glama, use Python 3.12, build step uv sync --frozen --no-dev, and command:

["mcp-proxy", "--", "env", "LOGIC_MCP_INSPECT_ONLY=1", "uv", "run", "--no-sync", "logic-pro-mcp"]

The explicit environment setting in the command keeps hosted instances in inspection mode. Dockerfile.inspection provides an equivalent local test image. Run uv run python scripts/check_inspection.py to verify real stdio discovery and that all 12 tools and 7 resources refuse execution. This is schema validation, not live Logic Pro validation.

Local installation

cd "/path/to/logic-pro-mcp"
uv sync
uv run logic-pro-mcp-doctor      # which channels are ready + what to click

Permissions (System Settings → Privacy & Security): Accessibility and Automation → System Events for the process that runs the server (Claude, Terminal, Hermes…).

Register

claude mcp add --scope user logic-pro-mcp -- uv run --directory "/path/to/logic-pro-mcp" logic-pro-mcp
hermes mcp add logic-pro-mcp --command uv --args run --directory "/path/to/logic-pro-mcp" logic-pro-mcp

(logic-mcp and logic-mcp-doctor still work as aliases of the two commands.)

Related MCP server: Logic Pro MCP Server

Tools

  • logic_system — health/doctor, permissions, midi_ports, key_map, ax_dump / ax_find (explore Logic's UI tree)

  • logic_transport — play, stop, record, go_to_beginning, rewind, fast_forward, toggle_cycle, toggle_count_in, toggle_metronome, set_tempo, goto, state

  • logic_tracks — list (optionally with colors), select, mute, solo, arm, monitor, set_volume (dB), set_pan, set_color / get_color (96-swatch palette: index, name like dark green, or hex), palette, create_*, delete, rename

  • logic_midi — note, chord, sequence, cc, program, pitch_bend, aftertouch, sysex, mmc, mcu_button/strip/fader

  • logic_plugins — insert by name, describe/get/set parameters in real units (dB, Hz, %), switches, presets

  • logic_level — measure rendered audio (LUFS, true peak, crest, correlation, spectrum) and balance the mix from it

  • logic_export — bounce (several formats in one pass), stems, read bounce settings, dismiss stray dialogs

  • logic_deliver — upload to cloud storage, or the whole chain: bounce, verify, upload, return share links

  • logic_project — launch, activate, quit, open, save, save_as, new, close, undo, redo, info

  • logic_osc — control surface: transport, select, mute, solo, volume, pan, bank, channel strip, Channel EQ, plug-in parameters

  • logic_offline — rename tracks, folders and mixer groups inside the saved project file, Logic closed

  • logic_keys — escape hatch: any key chord or named Logic command

Resources: logic://health, logic://transport, logic://tracks, logic://app, logic://markers, logic://mixer, logic://regions

Honest contract

Every write returns state: confirmed | uncertain | failed. Only confirmed means the change was read back from Logic. Destructive track ops require an explicit index/name and a confirmed selection, or they refuse.

The MCU surface only ever addresses the eight tracks Logic is currently showing on it — its bank buttons do nothing here. Which track sits on which strip is read back from the surface's own display, never assumed, and anything it cannot prove is routed through Accessibility instead. An earlier version assumed the bank and silently moved faders on tracks nobody had asked for.

Layout

logic_mcp/
  server.py          MCPServer, tools, resources
  doctor.py          channel health + fix plan
  target.py          find Logic (desktop / Creator Studio), pid, version
  result.py          confirmed / uncertain / failed envelope
  channels/
    midi.py          rtmidi + CoreMIDI: Logic Virtual In, MCU handshake/LEDs/LCD/faders/banks, MMC
    ax.py            generic Accessibility helpers (walk, find, press, set, dump)
    ax_logic.py      Logic-specific AX map (verified on 12.3 Creator Studio)
    palette.py       track color palette: swatch grid, names/hex, selection-ring readback
    screen.py        pixel readback (screen capture) for what AX can't see
    dialogs.py       macOS save panels, Logic alerts, popups, segmented bar/beat fields
    mouse.py         real HID clicks for controls whose AXPress is inert
    keys.py          CGEvent key posting + Logic default key commands
    applescript.py   osascript lifecycle helpers
  plugins.py         insert plugins, read/write parameters in real units
  audio.py           BS.1770 loudness, true peak, crest, correlation, spectral balance
  leveling.py        stem measurements -> gain and pan moves
  export.py          bounce / stem export, with completion proven on disk
  upload.py          rclone delivery to cloud storage

See FEATURES.md for the full matrix and PLAN.md for the research behind it.

Gesture and voice control

Hands and speech drive Logic through the same channels, via four small processes. Full write-up in docs/gesture.md; research and decisions in GESTURE_VOICE_PLAN.md.

Voice carries the nouns and the verbs; the hand carries the value. Say "volume on strings" and your hand is that fader until you let go. A DAW has ~1000 commands and ~100 tracks; a hand has six poses you can hit without looking, so the hand never names anything.

handd  (Swift, camera)  --UDP-->  gestured  --unix sock-->  logicpadd  --> Logic
voiced (Python, mic)    --UDP-->     |                          ^
                                     +--UDP--> hud              +-- logic-mcp

The model is never in the gesture loop. gestured writes OSC directly at ~45 ms hand-to-fader; a model only appears when the voice grammar misses, and then out-of-band on its own thread with a hard timeout so it cannot stall the hand.

logicpadd exists because only one process can hold UDP 9000 plus the Bonjour advert, and Logic segfaults if that advert disappears while it has the device bound. It owns the one surface and serves both the MCP server and the gesture daemon. With no daemon running everything falls back to binding directly, exactly as before.

The arbiter is a pure state machine with three rules: no target means no motion; poses are suppressed while the clutch is closed; and releasing the clutch freezes the value rather than resetting it — losing the hand is treated the same way.

logicpadd &          # owns the OSC surface; start first
gestured --dry-run   # decides everything, sends nothing
gesture-fakehand     # synthetic hand, no camera needed
gesture-hud          # always-on-top readout

Delivery

logic_deliver(action="bounce_and_upload", ...) runs the whole chain and hands back share links:

directory + filename + formats=["wav","mp3"]  ->  bounce (one pass, both formats)
                                              ->  verify sizes on disk
                                              ->  rclone copy to remote:folder
                                              ->  verify remote sizes match, return links

Measured at 68 s for a 9-bar preview of an 8-track project, WAV + MP3, uploaded and linked.

Uploads go through rclone rather than a Drive API tool, because bounced audio is large and binary and should stream from disk instead of passing through the model's context.

Uploads go to your own account. No credentials and no default remote ship with this server. Run logic_deliver(action="setup") for the exact commands; you run them yourself, and the sign-in happens in your browser under your own Google account — nothing is stored here. Pin a remote with $LOGIC_MCP_REMOTE or pass remote=. With several remotes configured and none pinned, delivery refuses rather than guessing which account your audio should land in.

Plugin control

Both reference projects declared plugin parameters unreachable. They are reachable, but the mechanics are odd:

  • AXValue is settable and reports success, yet moves one internal unit per call whatever number you pass.

  • AXIncrement / AXDecrement move ten.

  • Internal units map non-linearly to real ones (frequency is logarithmic), so the engine steps, re-reads the plugin's own readout, learns what a step is worth locally, and repeats until it is inside tolerance.

logic_plugins("insert", track=1, plugin="Channel EQ")
logic_plugins("set", parameter="Low Cut Frequency", value="90 Hz")     # -> confirmed, 20.0 Hz -> 90.0 Hz
logic_plugins("set", parameter="Peak 2 Gain", value="-2.5 dB")         # -> confirmed, 0.0 dB -> -2.6 dB

Values are checked for unit agreement first — a target in Hz aimed at a control that reads in percent is refused rather than driven somewhere absurd. Ratio readouts (4:1) and signed infinities parse correctly. Plugin editors are identified by structure (a bypass control plus a close button) rather than by "any window that is not the arrange window", so an open Mixer is never mistaken for one.

Coverage varies by plugin, and the tool is honest about it. Channel EQ names every control, so all 26 parameters and 14 switches are exact. The Compressor leaves its sliders anonymous with the names in separate text elements and readouts in percent; those are matched by on-screen position and marked labelled_by: "position". Any name that matches more than one control — Channel EQ has two sliders called Gain — is refused rather than guessed at. A parameter whose EQ band is switched off reports AXEnabled: false, and is either enabled first or refused.

Auto-leveling

Logic's meters report clipping only, with no numbers, so levels are measured from rendered audio instead — which is what a human engineer does anyway. Loudness follows ITU-R BS.1770-4 (K-weighting, 400 ms blocks, absolute and relative gating), alongside 4x-oversampled true peak, crest factor, stereo correlation and a seven-band spectral balance.

logic_level("plan",  directory="~/stems")            # measure and propose, nothing touched
logic_level("apply", directory="~/stems", dry_run=True)
logic_level("apply", directory="~/stems")            # set the faders, verified in dB
logic_level("export_and_plan", directory="~/stems")  # render stems out of Logic first

The reference stem — the lead vocal when it can find one — defines the balance: everything else is placed relative to it by role, so the mix keeps its character instead of being flattened to a number. Roles are guessed from stem names. Peaks are checked against a headroom line and moves are pulled back if they would breach it, and if any stem wants a boost the whole set is shifted down instead so nothing is pushed into the ceiling.

That shift moves the reference's own fader too — it is fixed relative to the others, not pinned at 0 dB. The plan reports it (global_shift_db, and shifted_by_db per move), and gain_uncapped_db keeps the pre-shift intent visible, so "this stem wanted to be louder" is not lost. After a downward shift no gain_db is positive; that is the design, not a clamp bug.

Measured on a real 5-stem session (460 s each): 6 s to analyse, 14 s to apply.

reference: VOX (vocal) at -17.3 LUFS
  Other    other     -16.7 LUFS   gain  -6.6 dB   pan +25
  GTR      guitar    -18.3 LUFS   gain  -5.0 dB   pan -40
  Bass     bass      -15.1 LUFS   gain  -4.7 dB
  Drums    drums     -15.3 LUFS   gain  -4.0 dB
  VOX      vocal     -17.3 LUFS   gain  +0.0 dB

Gains land within about 0.2 dB and are confirmed against Logic's own fader readout. Pan goes over OSC when the track is on the surface bank, where the readback is Logic's own value and the result is confirmed; otherwise it falls back to the track-header slider, which only moves by Increment/Decrement and settles within about 4 of 127, and that path stays uncertain rather than overstating itself.

Mix engine

Plain language in, stock plug-in settings out. "cut the mud in the strings" resolves the STRINGS family track, opens or creates its Channel EQ, and drives a recipe of parameter targets with readback.

34 recipes, each carrying synonyms, the plug-in it needs, per-source frequency overrides (vocals/strings/drums/bass/guitar/keys/mix), a caution, and cited sources. Third-party plug-ins work — FabFilter Pro-Q 3 lands on 300.00 Hz / −3.00 dB / Q 1.000 exactly. Targets are reached by bisection against the display string Logic echoes back, so the final number is Logic's own quantisation rather than ours.

Direction is never assumed: the DeEsser's Range runs backwards (0.0 = 25 dB), so the engine probes both endpoints, requires a fresh echo from each, works out which way the parameter runs, and refuses targets outside the achievable range.

Dialogue cues → markers

Finds where speech starts and stops in a mixed programme and writes the result into Logic as markers.

audio ──► detect_cues()  ──►  ASR (optional, pluggable)  ──►  cue-marker WAV  ──►  Logic markers
          no model, language-free

Detection never looks at phonemes or words, so the same code works in any language: it combines formant-band energy concentration (300 Hz–3.4 kHz) with syllabic amplitude modulation (3–8 Hz), both as percentile ranks within the file rather than fixed dB, so it self-calibrates to any programme level. Put 132 Tamil dialogue markers into a real episode.

Cues are capped at max_duration and split at their least speech-like interior frame, so a marker never covers half a scene. A measured music gate (off / safe / strict) drops cues whose spectrum is too steady to be speech — safe removes about 42 % of music false positives at a cost of about 5 % of dialogue, and rejected segments stay in the payload with their reason so a wrong call is auditable.

The gate is deliberately biased toward recall: a spurious marker is one click to delete, a missing one is a missed line. An earlier modulation-based gate that "obviously" made sense cut a real 132-cue run to 11.

Tests

uv sync --group dev
uv run pytest              # runs with Logic CLOSED and no Accessibility grant
uv run pytest -m live      # the few that need the app

The suite covers the parts that decide what is true: the result envelope, the OSC wire format and its measured address quirks, the ProjectData binary layout (against a synthetic file built independently to the documented format), dialogue detection, cue WAVs including UTF-8 Tamil labels, loudness maths, recipe resolution and which cloud account uploads go to.

Available Tools

12 tools
logic_deliverA

Get finished audio out of Logic and into cloud storage.

bounce_and_upload - the whole chain: render the project to `formats`, verify the files, upload them,
                    and return share links. Give directory + filename + formats + folder.
upload            - push existing local `paths` to remote:folder.
remotes / list    - what storage is configured, and what is already in a folder.
setup             - how the user connects their OWN cloud account.

Uploads go to the user's own remote: this server ships no credentials and no default account. The
remote comes from `remote`, else $LOGIC_MCP_REMOTE, else the single configured remote; with several
configured and nothing pinned it refuses rather than guessing. Run `setup` for the exact commands —
the user runs them themselves, since the flow ends in a browser sign-in to their own account.

Inputs: action (required), paths, folder, remote, +7 more.

logic_exportA

Render audio out of Logic and verify it landed on disk.

bounce  - one pass, several formats at once: formats=["wav","mp3"]. Optional start_bar/end_bar limit the range.
          sample_rate like "44.1 kHz", bit_depth like "24-bit", normalize "Off", mode "Offline".
stems   - File > Export > All Tracks as Audio Files, one file per track (the input for level analysis).
options - read the current bounce dialog settings without changing anything.
dismiss - close any stray Logic dialog (escape hatch).

Inputs: action (required), mode, end_bar, formats, +8 more.

logic_keysB

Escape hatch: send any key chord ('cmd+shift+n') or a named Logic command from key_map to Logic.

Inputs: chord, command.

logic_levelA

Measure rendered audio and balance the mix from it.

Logic's meters report clipping only, with no numbers, so levels are measured from audio rather than read
off the UI — which is what a human engineer does anyway.

analyse         - loudness (gated LUFS per BS.1770), true peak, crest, stereo correlation and spectral
                  balance for each file in `paths`.
plan            - the above, plus a proposed gain and pan per stem. Nothing is applied.
export_and_plan - render one stem per track out of Logic first, then plan.
apply           - carry the plan out on the matching tracks, verified in dB. dry_run reports what it
                  would do without touching anything.

mode matters. "relative" adds each gain to the track's CURRENT fader, which is right when the stems were
rendered through those faders (export_and_plan). It is NOT idempotent — running it twice applies the move
twice. "absolute" treats each gain as the fader position itself, which is right for stems that came from
outside this project, and is safe to re-run.

Inputs: action (required), mode, paths, dry_run, +6 more.

logic_midiC

Send MIDI into Logic's Virtual In (lands on the record-armed track) or drive the MCU surface.

Inputs: action (required), bpm, data, note, +9 more.

logic_offlineA

Read or rename track/folder/group names INSIDE a .logicx file, without driving Logic's UI.

list:   every patchable name in the project (kind: track | folder | group), plus counts.
rename: apply changes [{"old","new","kind"?}] to the project's ProjectData. By default writes to an
        APFS clone "<name> OFFLINE.logicx" next to the original (instant, no data copied); in_place
        patches the original after saving ProjectData.bak, and is refused while Logic has that
        document open (Logic would overwrite it on save). Returns uncertain: only Logic reopening
        the file proves the edit, so open the result and read the names back.

Inputs: action (required), project (required), changes, in_place.

logic_oscA

Drive Logic through its built-in TouchOSC "LogicPad" control surface over OSC (UDP), with feedback.

We advertise a Bonjour service in the TouchOSC Mk1 format, Logic binds it as a control surface (one-time
alert "OSC app TouchOSC wants to connect" -> Connect, pressed automatically), then Logic streams its state
(track names of the current 8-strip bank, select/mute/solo, volumes, meters, bar, SMPTE time, transport)
and accepts the fixed LogicPad address map. Faster and more reliable than Mackie emulation for transport,
selection and mixer moves; every result is read back from Logic's own OSC echo.

connect        bind the device (idempotent).            status    snapshot of everything Logic last sent.
transport      command=play|stop|record|cycle|rewind|forward|click|soloreset (record starts recording on
               armed tracks -- only on explicit request).
bank           command=bank+|bank-|track+|track-  (move the 8-strip window; strips are 1..8 inside it).
select|mute|solo  strip=1..8 (mute/solo toggle; readback says the new state).
volume         strip=1..8 value=0..1 (fader, 0.75 ~ 0 dB).   master_volume value=0..1.
send           address=/1/... args=[...] raw message; feedback returns what Logic sent in the last `wait` s.

Selected-track pages (select a track first):
strip          inserts (slot, name, bypassed), focused plug-in name + its 16 parameters (name, 0..1, display),
               sends, pan, mute/solo/arm of the SELECTED track.
eq             the Channel EQ on the selected track: 8 bands (1 high-pass, 2 low shelf, 3-6 peaks, 7 high shelf,
               8 low-pass) with on/gain/freq/q (+slope on 1 and 8), each as 0..1 and Logic's display value.
               present=false means the track has no Channel EQ (insert one via logic_plugins first).
eq_set         band=1..8 param=gain|freq|q|slope|on, then EITHER value=0..1 (raw) OR target=<number in
               Logic's units: dB, Hz, Q> which is reached by bisection on Logic's display value
               ("cut the mud": band=4 param=freq target=300; param=gain target=-3; param=q target=1).
plugin         command=slot+|slot-|page+|page-|bypass|open  (bypass/open take slot=1..12) on the selected track.
param          list the focused plug-in's parameters (same as strip.params).
param_set      param=<n or exact name> + value=0..1 or target=<number in the display unit>; read back.

Inputs: action (required), args, band, slot, +7 more.

logic_pluginsA

Read and write plugin parameters in real units (dB, Hz, %, ratios).

insert   - add a plugin to a track by name, e.g. plugin="Channel EQ" (uses Mix > Search and Add Plug-in).
describe - every parameter, switch and menu in an open plugin window, with its current readout.
get      - one parameter's current value.
set      - drive a parameter to a target: value="+3 dB", "1.2 kHz", "80 Hz", 2.0. Verified by re-reading
           the plugin's own readout. A parameter whose band is switched off is enabled first when
           enable_band is true, otherwise it refuses rather than silently doing nothing.
switch   - toggle a named switch (an EQ band, Analyzer, HQ...).
preset   - read the current preset name.
windows / close - list or close open plugin editors.

Inputs: action (required), on, track, value, +5 more.

logic_projectC

Project lifecycle via AppleScript + key commands. save/new/close use key commands (need Accessibility).

Inputs: action (required), path.

logic_systemC

Health, permissions, MIDI ports, menu bar (menu/press_menu with path like ['Track','New Audio Track']), and Accessibility exploration (ax_dump / ax_find) of Logic's UI.

Inputs: action (required), path, role, depth, +3 more.

logic_tracksA

Track list + per-track ops. Target by index (1-based) or name. Writes go via MCU (mute/solo/arm/select/volume) with Accessibility readback, or AX nudging as fallback. set_volume takes db (-inf..+6) or raw value 0-233 (173 = 0 dB); set_pan takes value 0-127 (64 = center). set_color takes color = 1..96 | '#rrggbb' | 'blue' | 'dark green' | 'light rose' (see action='palette'); verified by the palette's selection ring. list with colors=true samples header icon tints (approx).

Inputs: action (required), db, on, name, +5 more.

logic_transportC

Transport with verified readback (MCU LEDs + Accessibility). play/record via AX press; stop via MCU or Space.

Inputs: action (required), bar, beat, tick, +2 more.

Tool Schema Changelog

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

Loading tool schema changelog…

    TDQS

    B3.4/5.0

    Scored across 12 tools

    Disambiguation3/5

    Several capabilities are duplicated across channels: transport appears in both logic_transport and logic_osc (play/stop/record), mixer moves in both logic_tracks and logic_osc (volume/mute/solo), and plugin parameters in both logic_plugins and logic_osc (eq_set/param_set). The detailed descriptions explain when each channel is preferable, which prevents total confusion, but an agent still faces genuine misselection risk between the MCU/AX path and the OSC path.

    Naming Consistency5/5

    Every tool follows the same logic_<subsystem> pattern (logic_system, logic_tracks, logic_project, logic_plugins, etc.). The naming is highly predictable and the domain word cleanly signals the scope of each tool.

    Tool Count5/5

    12 tools is well within a healthy range and each maps to a distinct subsystem (transport, tracks, MIDI, project, export, plugins, level, OSC, etc.). Nothing feels padded or missing at the count level.

    Completeness4/5

    The surface is remarkably broad, covering health/permissions, transport, tracks, MIDI, project lifecycle, offline .logicx edits, export, cloud delivery, plugin control, level analysis, and OSC. Minor gaps remain around timeline/region editing, marker management, and bus/aux routing, but core workflows are covered.

    Maintenance

    ActivityMaintained
    ResponsivenessNo recent community issues

    Related MCP Connectors

    Related MCP Servers

    • A
      license
      A
      quality
      B
      maintenance
      FL Studio (Fruity Loops) MCP server. Control FL Studio 2025 and 2026 from Claude, Cursor, Codex or any MCP client: Mix Doctor diagnosis and fixes, gain staging, EQ/compression/reverb, plugin parameters in real units, piano roll, drum patterns, patterns, playlist and routing. 90 tools, every change can be undone. One-command setup on macOS; Windows needs loopMIDI.
      67
      93 PyPI
      146
      MIT
    • A
      license
      C
      quality
      B
      maintenance
      Enables MCP agents to inspect and precisely edit a running Ardour session — tracks, buses, groups, mixer, transport, regions, internal MIDI, plugins, routing and automation — through the DAW's Lua APIs with optional native OSC, plus offline audio analysis and comparison of master exports. Edits are exposed as 80 typed tools with persistent IDs, explicit units, preflight validation and structured change/error results.
      80
      GPL 3.0