How to Use Claude to Mix in REAPER

A plain chat window can’t hear your tracks and can’t touch your session. Paste it a bounced file and it can describe a spectrum back at you, in generic terms, once, with no way to check its own work. Connect an agent to REAPER through Reaper Daemon and it can read the actual project, plugins and all, run a measured before and after on a real mix move, and undo it with Ctrl+Z if it’s wrong. That’s the difference between advice and a tool with hands.

What you need

REAPER, Python 3.8 or newer, no pip packages. Claude Code or Claude Desktop, whichever you already have. That’s it. Reaper Daemon is a file bridge, not a plugin and not a server. The agent drops a JSON command file into a folder, a Lua script inside REAPER reads it and writes a result back. Nothing is listening on a port.

Setup

Clone it and run the installer.

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

On Windows, use python in place of python3. Restart REAPER. Then check the bridge is actually alive.

python3 reaperd.py status

If you’re on Claude Code, wire the MCP server in with one line.

claude mcp add reaper -- python3 /path/to/reaper-daemon/reaper_mcp.py

If you’re on Claude Desktop, add it to claude_desktop_config.json.

{ "mcpServers": { "reaper": {
    "command": "python",
    "args": ["C:/path/to/reaper-daemon/reaper_mcp.py"] } } }

Once it’s connected, you’re not typing commands. You’re talking. What’s on the bass bus. Carve 2 dB at 300 Hz on the ReaEQ. It reads your actual session and calls the tool.

A real mix session

Open your project, get the agent connected, and start with context instead of a request. Ask it what’s on the bass bus. It calls get_context or scan_fx and reads the real chain off the session, not a guess based on the track name.

Before it touches anything, it can also tell you what routing looks like. get_track_routing reads the actual sends and receives on the session, so if the bass is feeding a parallel compression bus you didn’t remember setting up, the agent sees that before it starts changing gain and confuses itself about where the signal is actually going. scan_fx dumps every plugin and every parameter on every track, by name, so it isn’t guessing that ReaEQ is the third slot. It read the chain and knows.

Say the low end feels muddy around 300 Hz. Ask it to carve some out. It finds a ReaEQ or adds one, sets the band, and instead of just telling you it did it, it verifies. That’s the whole point of the closed loop. verify_change captures the track, runs the mutation, captures the same spot again, and reports what actually moved. Here’s a real one, quoted straight from the docs, on a 2.5 dB ReaEQ gain cut on Bass. The spectrum line shows up when Post Mortem is installed.

[verify] pre: LUFS-I -14.1 | RMS -18.0 dBFS | scope isolated_track (verified) [verify] mutation set_fx_param: ok [verify] post: LUFS-I -14.9 | RMS -18.8 dBFS | scope isolated_track (verified) [verify] dLUFS-I -0.80 dRMS -0.80 dB [verify] biggest spectrum moves: 315 Hz -3.1 dB, 250 Hz -1.7 dB [verify] VERDICT: VERIFIED

That’s the receipt. Not “I made your mix better.” A measured LUFS delta and the specific bands that moved. ok: true from REAPER only means the command ran, not that the mix got better, which is exactly why verify exists as a separate step.

If you want a target instead of a guess, say so directly. Bring the bass down 3 dB LUFS. That’s tune_param, and it runs a baseline render plus up to five iterations, six renders total, searching the parameter until it converges or reports that it couldn’t. You’re not eyeballing a fader and rerendering by hand. The agent is.

Once you’ve landed on a setup you like on one song, save it. recipe capture grabs track order, folders, sends, levels, pans, plugin state, and automation, and recipe rebuild opens it in a fresh, unsaved tab on the next song so you’re not rebuilding your chain from scratch every time. It never touches your existing mix, and if a rebuild fails partway, the partial tab stays there for you to look at instead of vanishing.

None of this requires typing full sentences at it either, if you would rather work faster. reaperd.py send takes a JSON command file directly from the command line, and batch runs several of those in a single undo block, so a whole sequence of moves, EQ here, a send there, a level pull on the bus, lands as one Ctrl+Z instead of six.

What it can’t do

It measures. It doesn’t hear taste. LUFS, RMS, spectrum, that’s what verify gives you, and none of it is the same thing as whether the mix feels right. You audition. Every time.

analyze_track and compare_tracks, the tools that hand the agent LUFS, true peak, spectrum, stereo image and a masking table, need Post Mortem installed. Without it, verify reports LUFS-I deltas only.

Captures block REAPER’s UI for the render duration, by default 10 seconds. Two renders per verify call. Keep the capture window short or you’ll be staring at a frozen transport more than you’d like.

Some plugins carry opaque internal state that changes just from being loaded or inspected, separate from their exposed parameters. A mix recipe can report settings_match and still not sound identical on new material, because the hidden state isn’t something the bridge can see into. Audition the rebuild before you trust it.

And your ears are still the acceptance gate. The agent can tell you a resonance moved 3 dB at 250 Hz. It can’t tell you whether that’s the mix you wanted.

Versus the other options

An AI mixing plugin, the Neutron-style assistant that lives in one insert slot, only knows what’s happening in that slot. It balances what’s already on the track in front of it. This works across your whole session, your plugins, your routing, your bus structure, because it’s reading and driving REAPER itself, not analyzing audio in isolation inside a black box.

Upload your stems services take a bounced file, hand back a processed one or a report, and never touch your actual project. You get a result disconnected from your session, your automation, your plugin chain. This makes the change inside REAPER, wrapped in REAPER’s own undo, so the session you’re working in is the one that changes, not a copy of it somewhere else.

Both of those other approaches have their place. A plugin in one slot is fine when the problem really does live in that slot. A stem-upload report is fine when you just want a second opinion without granting anything access to your session. Neither one can look at your actual routing, catch a send you forgot about, or verify its own suggestion against the same track after the fact. That loop, propose, measure, show the delta, is what this is built around.

FAQ

Can ChatGPT or Claude mix my song from a chat window?

Not directly. A chat window has no access to your DAW. It can look at a bounced audio file if you upload one and describe what it hears in general terms, but it can’t read your plugin chain, can’t move a fader, and can’t verify anything it tells you. Connecting an agent to REAPER through a bridge like Reaper Daemon is what turns generic advice into an actual mix move with a measured result.

Is there a REAPER MCP server?

Yes. reaper_mcp.py in Reaper Daemon wraps the file bridge as an MCP server over stdio, no dependencies, no network listener. It works with Claude Desktop and Claude Code, and any other MCP client that speaks stdio.

Does the AI actually hear my mix?

No. It measures it. Integrated loudness, true peak, RMS, a spectrum breakdown. Those numbers get reasoned over, but reasoning over a measurement isn’t the same as hearing a mix the way you do. Taste stays yours.

Is it safe to let an agent make changes in my session?

Every mutation runs inside a REAPER undo block, so one Ctrl+Z reverts anything it does. Destructive tools ask the model to confirm intent first. Audio capture sits behind a config gate you have to turn on explicitly, and saving the project is a separate gate from measuring, so an agent measuring your mix never requires it to be able to save your file.

What’s the difference between this and an AI mixing plugin?

An AI mixing plugin lives in one slot and only knows what’s in that slot. This reads and drives your whole REAPER session, across every track and every plugin you already own, and every move it makes is verified against a before and after measurement instead of just applied and forgotten.

Reaper Daemon is free and open source. There’s a page for it here, and the code is on GitHub if you want to read exactly what it does before you let it touch anything.