Reaper Daemon
Reaper Daemon is a REAPER MCP server that lets an AI agent read, edit, and measure a REAPER project through a file-bridge, covering mixing, MIDI/drum/guitar/bass programming, automation, routing, and audio verification.
Status/context: check bridge heartbeat (
get_status), read project, tracks, FX names, markers, regions (get_context), and track routing (get_track_routing).Mix inspection: enumerate loaded FX and parameters (
scan_fx,get_fx_parameters), page through mix snapshots with meters (get_mix_snapshot), inventory plugins/presets (instrument_inventory).Mix editing: add/remove/bypass/move FX (
fx), set parameters in normalized, formatted, or relative units (set_fx_param), load/save host presets (get_fx_preset,set_fx_preset), set track volume/pan/mute/solo/arm/color (track), and control transport, tempo, cursor, and time selection (transport).Automation: read FX-parameter envelopes (
get_fx_param_automation), write one transactionally with rollback (write_automation), or atomically write several (apply_automation_transaction).Routing & MIDI linking: read/created sends and master feed (
get_track_routing,raw_command), map MIDI CC to FX parameters (link_fx_midi_cc), list and configure MIDI inputs (get_midi_inputs,configure_midi_input).Markers/regions/media: add/delete markers and regions (
markers), insert MIDI files (insert_midi_file), delete items in a range (delete_items_in_range), batch commands in one undo block (batch).MIDI & performance generation: insert raw hand-specified MIDI events (
insert_midi_events), humanized drum grooves from a DSL (insert_groove), humanized guitar/bass riffs (insert_riff), or a whole four-track jam (cut_band); re-humanize an existing take (humanize_take); insert a keyboard performance audition (insert_performance_audition).Drum/transcription work: profile a guitar stem bar-by-bar (
profile_track), derive kick grids (riff_grid), transcribe audio to drum MIDI (transcribe_drums,get_drum_transcription,insert_drum_transcription), and run drum composition workshops (drum_workshop).Audio measurement & verification: capture track WAVs (
capture_track_audio), analyze one track (analyze_track), compare masking across tracks (compare_tracks), prove a change with before/after deltas (verify_change), tune a parameter to a target loudness/band outcome (tune_param), complete Post Mortem onboarding (complete_postmortem_onboarding).Project/file management: save as a new .rpp or export a track template (
save_project_as), capture/diff/rebuild mix recipes (mix_recipe), and send any raw bridge command (raw_command).
Reaper Daemon
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.pyRestart REAPER, then check the bridge is alive:
python3 reaperd.py statusRendering 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-writesSaving 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, usepythonorpyifpython3isn'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-daemonThe 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 |
|
Discovery |
|
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 101MCP server. reaper_mcp.py wraps the bridge as tools over stdio.
Ask Claude Desktop to "measure the drums" and it does.
Daemon Console. A chat panel docked inside REAPER, backed by a headless Claude Code session that always knows which track you have selected.
Docs
one-line installer, ReaPack, manual load | |
| |
setup for Claude Desktop and other clients | |
the in-REAPER chat panel | |
kit discovery, stem profiling, humanize | |
writing full songs with sampled instruments: measure, articulate, vary cymbals, verify | |
separate composition briefs, MIDI comparisons, scoped audition feedback | |
audio to MIDI, background jobs, kit mapping | |
| |
capture, compare and rebuild a mix setup | |
closed-loop mix moves with measured proof | |
the file wire format | |
silent captures, stale heartbeats | |
unattended runs: relaunch REAPER, dialogs, stale queue files | |
instrument library, song sheets, approved drafts | |
trust model and the optional token | |
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_trackandcompare_tracksrun 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 toolsanalyze_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_transcriptionARead-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_presetARead-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_inputsARead-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.
link_fx_midi_ccB
Map MIDI CC to a scanned FX parameter and verify native parameter-link readback.
Inputs: controller (required), param_index (required), scale, track, +10 more.
list_actionsARead-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
Scored across 49 tools
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.
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.
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.
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
Related MCP Connectors
Remote MCP server for audio stem separation, denoise, reverb, and MIDI export.
MCP server for Producer/Riffusion AI music generation
MCP server for progressive tool usage at any scale (see https://klavis.ai)
A comprehensive Model Context Protocol (MCP) server that enables AI assistants to interact with yo…
Related MCP Servers
- AlicenseCqualityAmaintenanceA comprehensive MCP server that enables AI assistants to control REAPER DAW for mixing, mastering, MIDI composition, and full music production workflows with 130 tools.1872,076 PyPI104MIT
- AlicenseNot gradedqualityDmaintenanceAn MCP server that lets language models interact with the Reaper DAW1MIT
- AlicenseBqualityDmaintenanceThis 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.40MIT
- FlicenseAqualityDmaintenanceMCP 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-