Skip to main content
Glama

Reaper Daemon

Reaper Daemon MCP server – quality and maintenance score on Glama

Reaper Daemon is a REAPER MCP server and file bridge for driving REAPER from an AI agent, including mixing your session with Claude or any other agent. No network socket, no port, no extensions.

The agent drops a JSON command file in a folder. A Lua script inside REAPER runs it and writes a JSON result back. That's the whole protocol. It works with Claude Code, Codex, Cursor, or anything else that can read and write files, and an optional stdio MCP server, reaper_mcp.py, exposes the same bridge as tools for Claude Desktop and any other MCP client.

macOS, Windows, Linux. Pure Lua inside REAPER, plain Python 3 outside, no pip packages for the core bridge and MCP server. Audio-to-drum MIDI transcription uses a separate optional model environment. Every change runs inside a REAPER undo block, so Ctrl+Z reverts anything an agent does.

Install

Reaper Daemon has two halves, a Lua bridge that runs inside REAPER and the tools that talk to it. Both come from a clone of this repository on the computer REAPER runs on, so install here first, even if you found it through the Claude plugin directory.

git clone https://github.com/wretcher207/reaper-daemon.git
cd reaper-daemon
python3 setup/install.py

Restart REAPER, then check the bridge is alive:

python3 reaperd.py status

Rendering and audio capture are off until you allow them, and every measurement needs them, including verify_change. To do that, run:

python3 setup/install.py --allow-audio-writes

Saving the project, changing REAPER preferences and running Lua scripts have their own switches; see docs/install.md.

Prefer ReaPack, or want to load the bridge by hand? See docs/install.md.

Claude plugin

The repository is also a Claude plugin. It bundles the MCP server with five skills: setup, drum programming, drum humanizing, guitar and bass parts, and MIDI for an existing arrangement. The plugin drives the install above, so if you added it before installing, ask Claude to set up Reaper Daemon. The setup skill finds what's missing, runs the clone and installer with you, asks which disk writes to allow, and checks that REAPER answers.

When you add the plugin, Claude asks for two settings:

  • Reaper Daemon folder: where you cloned it. Default ~/reaper-daemon.

  • Python command: default python3. On Windows, use python or py if python3 isn't on your PATH.

Cowork doesn't ask, so it uses those defaults. To try the plugin in Claude Code straight from your clone:

claude --plugin-dir /path/to/reaper-daemon

The MCP server runs on your computer, next to REAPER. It works in Claude Code and in Cowork sessions on your machine. Chat on claude.ai loads the skills but can't reach REAPER.

Related MCP server: reaper-mcp-server

Mix with an AI agent

Point Claude, or any agent talking to Reaper Daemon, at your open REAPER session and ask it to work on the mix. It reads every plugin and parameter with scan_fx, sets FX values in real units like "-2.5 dB", and writes automation. verify_change captures the track before and after a move and reports what changed in the audio, so you are not taking its word for it. Every move sits inside a REAPER undo block, and your ears make the call.

Example prompts:

  • "The bass is muddy around 300 Hz, pull it down."

  • "Bring the vocal down so it sits with the mix instead of on top."

  • "Tune the bass until its LUFS is down 3 dB."

  • "What plugins are on the drum bus, and what are they set to?"

See MCP server for setup and Verify for what the measurements do and do not prove.

What it does

Area

Commands

Project

transport, tempo and the tempo map, cursor, time selection, render, save

Tracks

add, delete, rename, select, volume, pan, mute, solo, arm, color

Routing

read sends and receives, create sends, toggle master feed

FX

add, remove, bypass, reorder, set parameters, write automation, save chains

Markers, regions, media items

full read and write

MIDI

insert MIDI files, plus a drum DSL with humanization

Transcription

turn an audio item into drum MIDI with an optional local analysis runtime

Guitar and bass

shred renders a humanized riff, band cuts a whole rhythm section

Discovery

scan_fx dumps every plugin and parameter; discover_drum_map reads any kit's note map

Verify

measure loudness, spectrum and dynamics before and after a mix move

Actions and scripts

search and run anything in REAPER's action list; run Lua by source or path, behind its own switch

The bridge knows nothing about any specific plugin or drum library. Agents discover what a project contains and act on it by name.

Three ways to talk to it

CLI. One Python entry point for everything an agent does.

python3 reaperd.py send commands/examples/get_context.json --wait
python3 reaperd.py shred --track argent-l --bars-file riff.txt --seed 101

MCP server. reaper_mcp.py wraps the bridge as tools over stdio. Ask Claude Desktop to "measure the drums" and it does.

Reaper Daemon MCP server – quality and maintenance score on Glama

Daemon Console. A chat panel docked inside REAPER, backed by a headless Claude Code session that always knows which track you have selected.

Docs

Install

one-line installer, ReaPack, manual load

CLI

reaperd.py reference

MCP server

setup for Claude Desktop and other clients

Daemon Console

the in-REAPER chat panel

Drums

kit discovery, stem profiling, humanize

Composing workflow

writing full songs with sampled instruments: measure, articulate, vary cymbals, verify

Drum workshop

separate composition briefs, MIDI comparisons, scoped audition feedback

Drum transcription

audio to MIDI, background jobs, kit mapping

Guitar and bass

shred and band

Mix recipes

capture, compare and rebuild a mix setup

Verify

closed-loop mix moves with measured proof

Protocol

the file wire format

Troubleshooting

silent captures, stale heartbeats

Watchdog

unattended runs: relaunch REAPER, dialogs, stale queue files

Song planner

instrument library, song sheets, approved drafts

Security

trust model and the optional token

Develop

tests, CI, repo layout

Agents should read AGENTS.md, CLAUDE.md, and bridge/command_schema.md. Two bundled skills, arrangement-midi and drum-humanize, cover MIDI composition and drum humanization. song-planner plans and drafts whole songs from a brief, a riff or a reference.

Security

Any process that can write to inbox/ can drive REAPER. Keep the bridge folder local and off shared drives. Details in docs/security.md.

What it runs and sends

Everything runs on your machine. The MCP server and CLI are plain Python with no network calls. The bridge is a Lua script inside REAPER. It trades JSON files with the server through the Reaper Daemon folder, which also holds logs and the MIDI files it generates. Renders and captures write audio files only if you turn on audio writes, which are off by default. Nothing leaves your computer.

Three optional pieces do more, and only if you install them:

  • Drum transcription downloads its Python packages and model weights during setup, and Demucs downloads its weights on the first separation job. Audio stays local.

  • analyze_track and compare_tracks run Post Mortem from your PATH.

  • The Daemon Console starts a Claude Code session on your machine, which talks to Anthropic like any Claude Code session.

License

MIT. See LICENSE.

Keyboard performance setup, MIDI/controller tests and template saving are documented in the performance workflow.

Available Tools

49 tools
analyze_trackA

Post Mortem (the separate post-mortem audio-analysis CLI that renders a track and measures it): capture one verified-isolated track and return MEASURED mix data (FX chain with values, routing, LUFS, true peak, crest, 1/3-octave spectrum, stereo image, silence fraction) for YOU to diagnose. Requires Post Mortem installed and capture enabled (see capture_track_audio gating). Full-mix fallbacks are refused. Park the edit cursor where the track is playing first.

Inputs: track (required), seconds.

apply_automation_transactionA

Atomically write several FX-parameter envelopes (e.g. a stereo pair) in one undo block. Every envelope is snapshotted before mutation; any failure restores all of them and rereads the restoration before reporting.

Inputs: writes (required), dry_run, transaction_id.

batchA

Run several bridge commands as ONE undo block and one round-trip. commands: [{type, payload}]. Use for multi-step edits (e.g. several set_fx_param calls) so a failure stops cleanly and one Ctrl+Z reverts everything. Nested batches are refused. Returns {results: [per-command result], all_ok, failed_index, completed, total, stopped, rolled_back}. With stop_on_error (default) a failure stops the batch and the call errors with the failing command's code and index, unless return_partial_results is true, which returns the object above with stopped=true instead. Commands already run are NOT rolled back; undo the block.

Inputs: commands (required), dry_run, undo_label, stop_on_error, +1 more.

capture_track_audioA

Render a track capture to WAV and return its evidence scope. Only isolated_track with isolation_verified=true is per-track audio; item-based tracks can report a full_mix fallback. Gated: needs allow_audio_writes=true (or the legacy allow_risk_level_3 fallback) in bridge/bridge_config.json (python3 setup/install.py --allow-audio-writes writes it; capture does NOT need save_project or preference rights) AND the change applied by the reload_bridge command, or a REAPER relaunch — the flag is read once per bridge load. Synchronous — blocks the bridge for the render duration.

Inputs: track, output_file, start_seconds, track_contains, +3 more.

compare_tracksA

Post Mortem cross-track masking: capture 2+ verified-isolated tracks and return their spectra plus a contested-band masking table for YOU to diagnose. Full-mix fallbacks are refused. Same requirements as analyze_track. Use analyze_track for one track's own mix problems; use this when two parts fight for the same frequencies.

Inputs: tracks (required), seconds.

complete_postmortem_onboardingA

After analyze_track, send the exact diagnosis you wrote to the Post Mortem panel. Requires a fresh matching 10-second single-track handoff; comparisons cannot complete first-run onboarding.

Inputs: track (required), diagnosis (required).

configure_midi_inputA

Set one track's record input to a MIDI device and channel, optionally record-arm it and turn input monitoring on or off, then read the values back. Omitted arm/monitor are left unchanged; the record input is always set (device 63, channel 0 when omitted). Returns {track_guid, input, armed, monitoring}, where input is REAPER's I_RECINPUT code (4096 + device*32 + channel). Errors: NO_MIDI_INPUT (device index not present), BAD_PAYLOAD (value out of range), VERIFY_FAILED (REAPER did not keep the setting), NO_TARGET_TRACK / AMBIGUOUS_TARGET_TRACK. Undoable. Use get_midi_inputs first to find the device index.

Inputs: arm, track, device, channel, +5 more.

cut_bandA

Lay down or re-cut a whole four-track jam in ONE call: two double-tracked guitars, a bass locked to them, and drums. The two guitars get different seeds automatically, so the width is two performances rather than a stereo copy. By default it REPLACES what is on those four tracks from position — pass replace=false to append instead. Every leg is attempted even if an earlier one fails, and the result reports each leg separately, so a partial cut says which tracks landed. MUTATES the project (undo-block wrapped). Refuses in ~0 s when the bridge heartbeat is dead.

Inputs: map, bass, riff, drums, +11 more.

delete_items_in_rangeA

Delete media items in a time range on one track (or all_tracks). Destructive — confirm intent; undo-block wrapped; supports dry_run.

Inputs: range, track, dry_run, all_tracks, +5 more.

drum_workshopA

Prepare separate composition requests, compare authored drum DSL candidates, export MIDI, or record explicit user audition feedback. Local files only; never changes REAPER. Fresh and wildcard requests omit reference patterns. The calling agent writes candidate.dsl and intent.json before evaluate. Comparisons measure structural similarity, not musical quality. No model is invoked and no winner is selected.

Inputs: path (required), action (required), output, feedback.

fxA

FX chain operations: add (fuzzy plugin-name resolution against REAPER's installed-plugin cache), remove, bypass, move. Undo-block wrapped; supports dry_run (dry_run add needs the exact fx_name, no fuzzy resolution). TO ADD A PLUGIN, JUST RUN add IN ONE CALL. The resolver against the installed-plugin cache IS the check — a plugin being absent from the project is normal and expected (adding it is the whole point). Do NOT precheck with scan_fx, do NOT hedge about whether it's installed, do NOT narrate a plan. Target the master with track:"master". The user may be recording live; extra steps and preamble ruin the take. To change a parameter on an FX already in the chain use set_fx_param.

Inputs: action (required), show, track, bypass, +9 more.

get_contextA

Read the open REAPER project: name, tempo, transport, cursor, time selection, every track (with FX names), markers, regions. Read-only. Run before ambiguous edits.

Inputs: include_fx.

get_drum_transcriptionA
Read-only

Read a drum transcription job's progress, failure, output files and insertion receipt. A completed analysis has not inserted anything into REAPER.

Inputs: job_id (required).

get_fx_param_automationB

Read one existing FX-parameter envelope without creating or arming it. Returns envelope state, inclusive-range points, optional neighbors, automation items, duplicate times, and a canonical content hash.

Inputs: track, fx_guid, end_time, fx_index, +9 more.

get_fx_parametersA

Full parameter list for ONE FX (auto-paginated): index, name, normalized value, formatted display value. Scan before setting parameters; prefer param_index from this scan over name matching.

Inputs: track, fx_index, fx_scope, include_values, +5 more.

get_fx_presetA
Read-only

Read-only: report which REAPER host preset is loaded on one FX. Pick the track with one track selector and the FX with one FX selector (fx_guid, else fx_index + fx_scope, else fx_name_contains). Returns {name, valid, index, count, scope}; valid is false when the plugin reports no named preset. Only sees REAPER host presets, not a plugin's own preset browser. Errors: NO_FX / AMBIGUOUS_FX / AMBIGUOUS_SCOPE / NO_FX_SELECTOR, NO_TARGET_TRACK / AMBIGUOUS_TARGET_TRACK. Use set_fx_preset to change it.

Inputs: track, fx_guid, fx_index, fx_scope, +4 more.

get_midi_inputsA
Read-only

Read-only: list the MIDI input devices REAPER can see. Takes no arguments. Returns {inputs: [{index, name, available, configurable}], all_devices: 63, virtual_keyboard: 62}. Call this before configure_midi_input to find a device index; configurable is false for indices above 63, which configure_midi_input cannot set.

Inputs: no named parameters.

get_mix_snapshotA

Read a bounded page of tracks, master, GUIDs, routing, FX, optional parameter values and instantaneous peak meters in one hop. Use measure for integrated audio evidence.

Inputs: limit, offset, max_params, target_track_guid, +1 more.

get_statusA

Check the bridge is alive inside REAPER (heartbeat, open project, whether risk-level-3 commands like audio capture are enabled). Call this first.

Inputs: no named parameters.

get_track_routingA

Read a track's routing: sends, receives, parent bus, volume, pan, phase, automation mode. Read-only.

Inputs: track, track_contains, target_track_guid, use_selected_track.

humanize_takeA

Put a dynamic contour and micro-timing into a drum take that is ALREADY on a track — the take is read, planned, and written back in place through index-addressed note edits, so stacked hits (flams, double triggers) are humanized too. The contour is always applied; amount only scales the random spread and timing looseness on top of it. Fills build as a crescendo peaking at the resolve, and the golden rule is enforced: no drum hits the same velocity twice in a row. Use follow_lead when the user has already humanized the opening bars BY HAND and wants that hand carried across the rest — it learns from their bars instead of applying the shared taste model, and fails if there is no flat region left to follow into. Prefer dry_run first: it plans and returns the full summary without writing. MUTATES the project (undo-block wrapped, one Ctrl/Cmd+Z reverts the whole pass).

Inputs: track (required), map, seed, amount, +4 more.

insert_drum_transcriptionA

Map a completed transcription to a drum kit and insert verified notes into REAPER. Requires the original source item and an empty destination range. Refuses source changes, duplicate jobs and active transport. Auto-discovers note names or accepts a catalog map_name. dry_run validates without writing. Keeps original audio, track mute state and project tempo unchanged. One undo reverts insertion.

Inputs: track (required), job_id (required), dry_run, map_name.

insert_grooveA

Render a drum DSL to MIDI and insert it on a track in ONE call — the engine (skills/drum-apparatus/) humanizes velocity, fatigue and timing at placement. Give the DSL EITHER inline as dsl_text OR as a file with dsl_path, never both. MUTATES the project (undo-block wrapped, one Ctrl/Cmd+Z reverts); supports dry_run. Refuses in ~0 s when the bridge heartbeat is dead, before generating anything. The rendered .mid is KEPT under rendered-midi/ — REAPER imports MIDI by reference on this build, so a deleted render leaves an empty take. Kit map: the DSL's own @map wins, then this map argument, then drum-config.json, then GM Standard. Track: named track, else drum-config.json's default, else REAPER's selected track. A bad DSL comes back as DSL_ERROR with the engine's own message — fix the DSL from it.

Inputs: map, seed, track, dry_run, +6 more.

insert_midi_eventsA

Create a new MIDI item on one track from a list of raw events (notes, CC, pitch bend, program change), with no humanizing. Use this for exact, hand-specified MIDI; use insert_midi_file when a .mid already exists, insert_groove for humanized drums, insert_riff for humanized guitar or bass, cut_band for a whole four-track jam. Two timing units. Default time_unit "seconds": start_seconds + length_seconds, event time and duration in seconds from the item start. time_unit "beats" (use this to write music): start_bar (1-based) or start_beats (project quarter notes), length_beats, and event time and duration in quarter notes from the item start, so notes follow the tempo map. Mixing units is refused. For drums, keep the golden rule yourself: no drum hits the same velocity twice in a row. Returns {track_guid, notes, controls, time_unit, start_seconds, length_seconds} plus start_bar/start_beats/length_beats in beats mode. Errors: BAD_PAYLOAD (an event or the timing is out of range; nothing is written), INSERT_FAILED / VERIFY_FAILED (the new item is deleted again). Undoable.

Inputs: events (required), track, dry_run, start_bar, +8 more.

insert_midi_fileA

Insert a .mid file from disk onto a track at a position. Write the MIDI yourself, then insert. Never overwrites existing items unless replace_existing_in_range is true. Use this when a .mid file already exists; to build MIDI from a list of notes use insert_midi_events, for humanized drums insert_groove, for guitar or bass insert_riff.

Inputs: midi_path (required), loop, track, length, +6 more.

insert_performance_auditionB

Insert a repeatable 15-second melodic test of expression, modulation, sustain and octave range. Use a separate audition project. Render with capture_track_audio and audition; MIDI success does not prove controller response.

Inputs: target_track_guid (required), pitch, dry_run, start_seconds.

insert_riffA

Render ONE humanized guitar or bass part and insert it on a track (skills/guitar-apparatus/). Write the riff as bars_text — one 16-step bar per line, e.g. 'x.x.x.x.x.x.x.x.' — or point at a file with bars_file, never both; omit both to use the built-in 'demo' riff. Step alphabet: '.' rest, 'x' muted chug, 'X' accented root, 'o' let-ring root, 'g' ghost, '_' tie the previous note through this step, '~' slide into the next; UPPERCASE note names (E F G A B C D) are power chords in the key of E and lowercase are single notes, so case matters. Read skills/guitar-apparatus/SKILL.md for the full table before writing anything beyond chugs. Double tracking is two performances, not a copy: call this twice with DIFFERENT seeds for the left and right guitar. MUTATES the project (undo-block wrapped, one Ctrl/Cmd+Z reverts). Refuses in ~0 s when the bridge heartbeat is dead. The rendered .mid is kept under rendered-midi/, including on a dry run, because REAPER holds it by reference.

Inputs: track (required), map, part, riff, +8 more.

instrument_inventoryC

Discover plugin cache entries and local preset files. Results do not prove plugins load or samples are available.

Inputs: limit, query, content_roots.

instrumentsA

Named instrument library, so a sound is picked by name instead of by plugin index. list/show: read-only; each entry has role, library, note maps (guitar/bass/drums map names the generators use), playable range, tags, and the saved chain name or none. save: the user has loaded a sound by hand on 'track' (any Kontakt library or Serum preset); this saves that track's FX chain, plugin state included, as FXChains/instrument- and registers it. load: splice a saved instrument onto an EMPTY track (refused if the track has FX unless allow_existing_fx) and verify the FX landed; use the entry's maps when writing notes. remove: drop a user entry (shipped catalog entries stay). save_rig: for a multi-output instrument (a Kontakt kit feeding Kick/Snare/room tracks), save the instrument track plus every track its sends and folders reach as a track template; load of a rig adds all those tracks and returns play_track_guid, where the MIDI goes. Errors name the problem; nothing is half-registered.

Inputs: action (required), tag, maps, name, +9 more.

list_actionsA
Read-only

Search REAPER's action list: every word in query must appear in the action name or its _SWS/_RS id. Returns command_id, name, named_id and toggle_state per match, paged by limit/offset. Sections: main (default), main_alt, midi_editor, midi_event_list, midi_inline, media_explorer.

Inputs: limit, query, offset, section.

markersC

Add or delete markers and regions (add_marker, add_region, delete_marker).

Inputs: action (required), end, name, color, +6 more.

mix_recipeB

Capture a local mix recipe, compare it with the current session, or rebuild it in a separate project tab. Original tab is restored. Media is excluded.

Inputs: path (required), action (required), dry_run.

profile_trackA

Daemon Beater: profile a guitar stem bar by bar to plan drums — onset density, IOI regularity, decay ratio (palm-mute vs ringing), silence, low/bright balance, RMS/crest, a 16th accent grid, plus suggested section boundaries and repeated-section groups (A/B/A). READS THE SAVED .rpp FILE ON DISK, NOT REAPER's live project: unsaved edits are invisible, so on a dirty project this analyzes stale material. The result repeats that caveat — relay it, never present these numbers as the current session. Numbers, not verdicts: YOU propose the section labels and the user corrects them. Point it at the DI track, not the amped stem (distortion flattens the decay contrast) and say which you used. Slow (up to 600 s on a long stem) — window it with bars / start_bar / max_seconds.

Inputs: track (required), project (required), bars, start_bar, +1 more.

raw_commandA

Escape hatch: send any bridge command by type + payload (full reference: bridge/command_schema.md). Use when no dedicated tool covers it.

Inputs: type (required), dry_run, payload, timeout_ms.

riff_gridA

Step 1 of the drum workflow: read a guitar stem's transients into a proposed KICK GRID, printed at 100/50/30% attack strength. READS THE SAVED .rpp FILE ON DISK, NOT REAPER's live project — same stale-material caveat as profile_track, and the result carries it. This is a PROPOSAL the user corrects, not an auto-beat: transients say WHEN a note is picked, never whether it rings open or is palm-muted, so the percentile is an attack-strength heuristic. The 30% row is the sparse slam/breakdown feel (the default); the 100% row turns every pick attack into a kick (gallops/triplets). The grid is anchored to item time 0, so a stem whose downbeat sits a step off reads a 16th early — check the first render. Transcribe the row the user picks into a DSL, then insert_groove.

Inputs: track (required), project (required), bars, start_bar.

run_actionA

Run one REAPER action by command_id (a number from list_actions) or named_id (an SWS... / _RS... string), in the main section or a MIDI editor section. Runs in an undo block. Save and render actions obey the same gates as save_project and render; Quit is refused. An action that opens a dialog will block the bridge until it is closed.

Inputs: dry_run, section, named_id, command_id.

run_scriptA

Run Lua inside REAPER with the full ReaScript API: pass code (source text) or path (a .lua file; relative paths resolve under the daemon folder, then REAPER's Scripts folder). The script's return value and anything it printed with ShowConsoleMsg come back in the reply; reaper.defer is not available (the script must finish in one pass) and it is stopped after timeout_seconds (default 30). Project changes land in one undo block. Off until allow_script_execution is true in bridge_config.json (python3 setup/install.py --allow-script-execution).

Inputs: args, code, path, dry_run, +1 more.

save_project_asA

Save to a NEW absolute .rpp path, or export explicitly named tracks as a media-free .RTrackTemplate. Existing files are refused. Requires project save gate.

Inputs: path (required), track, dry_run, fx_guid, +8 more.

scan_fxA

Enumerate FX and their parameters — one track or the whole project (omit the track selector). Read-only. Lists only FX ALREADY LOADED in the project, NOT your installed-plugin library. Never use it to check whether a plugin exists before adding one — that is the fx add resolver's job.

Inputs: track, include_values, track_contains, target_track_guid, +1 more.

set_fx_paramA

Set one FX parameter. Give normalized_value (0-1), formatted_value (e.g. '-16.00 dB', '80 Hz' — the bridge binary-searches the normalized value whose display matches), or relative ('+0.1'). Scan with get_fx_parameters first and prefer param_index. Undo-block wrapped; supports dry_run.

Inputs: track, dry_run, fx_index, fx_scope, +9 more.

set_fx_presetA

Load an exact REAPER host preset name and verify readback. Proprietary preset files may require plugin UI; saved chains use add_fx_chain.

Inputs: name (required), track, dry_run, fx_guid, +6 more.

song_planA

Song planner. A sheet JSON (see docs/song-planner.md and skills/song-planner) holds title, tempo, key, parts (instrument-library names) and sections with bars, energy, drum lanes, 16-cell riff bars and layer notes. check: every problem at once. show: the readable sheet to put in front of the person. approve: ONLY after the person explicitly said yes to the whole sheet; any later edit cancels it. draft: refuses an unapproved sheet, then opens a NEW project tab and writes tempo, tracks, saved sounds, a region per section, drums, both guitars, bass and layers, each step reported separately. 4/4 and one tempo per song only. Never saves the project.

Inputs: sheet (required), action (required), seed.

trackB

Track operations: add, delete, rename, select, set_volume (dB), set_pan (-1..1), mute, solo, arm, set_color. Every mutation runs in a REAPER undo block. Supports dry_run. delete is destructive — confirm intent first.

Inputs: action (required), pan, mute, name, +13 more.

transcribe_drumsA

Start local audio-to-drum-MIDI analysis in a background worker. Uses one selected audio item or a named source track/item. Returns a job_id; poll get_drum_transcription, then use insert_drum_transcription. Needs the optional transcription environment and ffmpeg. May download model weights on first use; audio stays local. Does not change the project. Tom and cymbal articulations are estimates.

Inputs: device, threads, separate, item_index, +2 more.

transportB

Transport and project timing: play, stop, pause, record, set_cursor, set_time_selection, set_tempo (the project's base tempo), plus the tempo map: get_tempo_markers, set_tempo_marker (a tempo and/or time-signature change at a position; a time-signature change needs a bar position; index edits an existing marker) and delete_tempo_marker. Mutations run in an undo block (Ctrl/Cmd+Z reverts).

Inputs: action (required), bpm, end, clear, +9 more.

tune_paramA

Outcome-driven parameter search: iteratively set ONE FX parameter and re-measure until a target audio outcome is hit (e.g. bass LUFS-I down 3 dB), then report the measured result. Target: {"metric": "lufs_i"|"band_db", "delta": -3.0, "tolerance": 0.5, "band_hz": [lo,hi] for band_db (needs Post Mortem)}. delta is relative to the baseline measurement. ASSUMES the metric moves monotonically with the parameter (gain-like params); stops with NON_MONOTONE and restores the initial value when that is violated. EXPENSIVE: baseline + up to 5 iterations, each a render that blocks REAPER's UI — warn the user before calling. Each set is one undo point. On UNCONVERGED/UNREACHABLE the best-observed value stays applied and the result says so honestly; final always carries the READ-BACK live parameter state. Requires ONE FX selector (fx_name_contains or fx_index) AND one parameter selector (param_index or param_name_contains). Needs allow_audio_writes.

Inputs: track (required), target (required), seconds, fx_index, +4 more.

verify_changeA

Run ONE mutating bridge command with MEASURED proof: capture the track, apply the command, capture the same frozen window again (track pinned by GUID), and report audio deltas (LUFS-I always; spectrum/peak/stereo with Post Mortem). This REALLY mutates the project (undo-block wrapped; one Ctrl/Cmd+Z reverts) — confirm intent first for destructive command types (delete_track, delete_items_in_range, remove_fx). Costs TWO renders; each blocks REAPER's UI for the capture duration. Statuses: VERIFIED (deltas are real measurements); REFUSED (refused before the mutation was sent, no mutation ran); UNVERIFIED (the project MAY have changed: applied, partial batch, rejected by the bridge with a possible mid-edit partial change, or unknown outcome; not measured either way; NOT rolled back; do NOT retry blindly). Relay the status honestly; never present UNVERIFIED as success. Needs allow_audio_writes (see capture_track_audio).

Inputs: track (required), payload (required), command_type (required), seconds.

write_automationA

Write one FX-parameter envelope transactionally: snapshot, inclusive-range replacement, reread confirmation, and automatic rollback on any failure. A declared range always means replacement.

Inputs: points (required), track, ranges, dry_run, +9 more.

Tool Schema Changelog

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

Loading tool schema changelog…

    TDQS

    B3.2/5.0

    Scored across 49 tools

    Disambiguation3/5

    The descriptions are unusually explicit and cross-reference each other (e.g. insert_midi_events vs insert_midi_file vs insert_groove vs insert_riff), which rescues a lot. But with 49 tools there are still real boundary clusters: five audio-measurement tools (capture_track_audio, analyze_track, compare_tracks, verify_change, tune_param), four drum/MIDI-generation paths (riff_grid, profile_track, insert_groove, drum_workshop, transcribe_drums/insert_drum_transcription), and three automation writers (write_automation, apply_automation_transaction, batch) that an agent must reason carefully to pick between.

    Naming Consistency3/5

    Everything is snake_case, so casing is consistent, but the verb convention is not: many tools are verb_noun (get_status, set_fx_param, insert_groove, capture_track_audio) while others are bare domain nouns that dispatch on an action argument (track, transport, markers, fx, batch, instruments, song_plan). Readable, but an agent cannot infer from a name alone whether the operation is a noun-with-action or a fixed verb.

    Tool Count2/5

    49 tools is well past the 25-tool threshold and the surface includes long-tail capabilities (verify_change, tune_param, complete_postmortem_onboarding, insert_performance_audition, drum_workshop) that most sessions will never touch. Each is individually defensible for a full DAW bridge, but the set as a whole is heavy enough that selection accuracy and prompt budget suffer.

    Completeness4/5

    Coverage of the DAW domain is broad: transport/tempo map, tracks and routing, FX chain and parameters, automation, MIDI generation across several engines, markers/regions, save/templates, actions/scripts, and measured audio analysis. Gaps are real but mostly second-order — there is no media-item listing/inspection or item editing (split, trim, move, fades), no master-volume/mix write tool, and no undo/redo management, all of which some workflows will hit as dead ends.

    Maintenance

    ActivityMaintained
    ResponsivenessLimited data

    Related MCP Connectors

    Related MCP Servers

    • A
      license
      B
      quality
      D
      maintenance
      This MCP server enables AI assistants to control a live REAPER DAW instance, including transport, tracks, FX, MIDI, media, markers, rendering, and project state, with an escape hatch for arbitrary ReaScript commands.
      40
      MIT
    • F
      license
      A
      quality
      D
      maintenance
      MCP server for controlling REAPER digital audio workstation from natural language. It enables AI agents to create tracks, import audio, adjust mix parameters, and manage sessions through typed operations and a REAPER bridge.
      22
      -