Skip to content
GrooveKit
Download
Open sourceEarly development

You direct.The agent produces.

GrooveKit is an agent-first music production app for macOS. Claude arranges, mixes, automates and masters through the same API as the interface — every change shows up live in your window, and one undo takes it back.

Download for macOSView on GitHub

Free · Apple silicon · macOS 12 or later · All releases

First launch: macOS asks you to confirm it once, under Privacy & Security.

How the agent works

Ask in words. Watch it happen in the app.

GrooveKit gives Claude 20 tools over the Model Context Protocol: the same engine API the interface is built on. Anything you can click, the agent can do — and anything it does, you can see, change and undo.

  1. 01

    Connect Claude once

    GrooveKit comes with an MCP server: the standard way Claude picks up new tools. Register it with Claude Code and the studio is one of Claude’s toolboxes.

    $ claude mcp add --scope user groovekit -- node /path/to/groovekit/mcp/src/index.ts
  2. 02

    Say what you want

    A genre, a tempo, a feeling, a reference loudness. Or something smaller: “the hats are too busy in the drop”. The agent reads the song before it touches it.

  3. 03

    Watch, listen, undo

    Each edit lands in the open app as it happens, outlined in violet and listed in the Agent tab. A whole request is one undo step, so trying an idea costs nothing.

claude — ~/Music/GrooveKit/Scratch
  1. > Make a dark techno groove at 128 from my own samples: four-on-the-floor kick, offbeat bass, busy hats. Keep the kick and bass out of each other’s way, then master it for streaming.
  2. groovekit ·get_summary
    ⎿ tempo 120 · 0 channels · 0 patterns · empty playlist
  3. groovekit ·search_samples
    {"query":"dark kick","category":"kick","loop":false,"limit":5}
    ⎿ Kicks/Industrial Kick 03.wav
    “kick one-shot, 0.42 s, pitched F1, sharp attack, dark, bass-heavy”
    5 of 38,214 samples
  4. groovekit ·search_samples
    {"query":"reese bass","category":"bass","loop":false}
    ⎿ Bass/Reese Stab F.wav · rootKey 29
    “bass one-shot, 0.61 s, pitched F1 (−8 c), sharp attack, bass-heavy”
  5. groovekit ·edit_project
    {"label":"Dark techno groove","commands":[
  {"type":"setTempo","tempo":128},
  {"type":"addChannel","channel":{"id":"kick","instrument":{"type":"sampler",
    "layers":[{"id":"l1","sample":"…/Industrial Kick 03.wav","pitchTracking":false}]}}},
  {"type":"addPattern","pattern":{"id":"groove","length":3840,
    "notes":[{"channel":"kick","start":0,"length":240}, …]}},
  {"type":"addClip","clip":{"type":"pattern","id":"g1","track":"drums",
    "start":0,"length":61440,"pattern":"groove"}},
  … 12 more]}
    ⎿ entry 14 · “Dark techno groove” · applied atomically
  6. groovekit ·analyze_mix
    {"startBar":1,"endBar":17}
    ⎿ mix −17.6 LUFS · true peak −3.2 dB
    masking: kick × bass at 60–120 Hz
  7. groovekit ·edit_project
    {"label":"Carve room for the kick","commands":[{"type":"addEffect","insert":"bass",
  "effect":{"type":"builtin","id":"eq","kind":"eq","params":{"lowFreq":110,"lowGainDb":-4}}}]}
    ⎿ entry 15 · “Carve room for the kick”
  8. groovekit ·master
    {"targetLufs":-14,"ceilingDb":-1}
    ⎿ integrated −14.1 LUFS · true peak −1.0 dB · reached target in 3 renders
  9. groovekit ·transport
    {"action":"play","fromBar":1}
    ⎿ playing · song mode · bar 1

  10. Done: 16 bars at 128 BPM with kick, offbeat bass and 16th hats, a low shelf on the bass so the kick owns 60–120 Hz, mastered to −14 LUFS. It’s playing now. One undo takes the whole thing back.

An illustrative session. Tool names and arguments are GrooveKit’s real ones; sample names and numbers will be yours.

One engine. You and the agent are peers.

The audio engine owns the song. The app and the agent are both clients of its JSON-RPC API over WebSocket, sending the same typed commands. Each command becomes a history entry, and every client gets the change as a live patch — that’s how the agent’s edits appear in your window the moment it makes them.

Read the engine API
GrooveKit app
You: clicks, keys, knobs
Engine
Song, history, playback, render, analysis
ws://127.0.0.1 · JSON-RPC
Claude
via the GrooveKit MCP server

Agent tools

20 tools. The whole studio, in the agent’s hands.

Coarse tools rather than hundreds of tiny ones, so the agent’s context stays small and its plans stay simple. Read the song, change it in one atomic step, render, measure, adjust.

Picks sounds from your library

The agent searches the samples you already own, by words, category, loop, tempo and key, and reads a description of every sound before it uses it.

  • search_samplesFinds samples by words, category (kick, snare, hat, bass, synth, vocal, fx…), one-shot or loop, tempo (half and double time match) and key. Each result says what it sounds like: “kick one-shot, 0.42 s, pitched F1, sharp attack, dark, bass-heavy”, plus its detected root key.
  • describe_sampleFull measurements of one file: duration, loudness, attack and decay, spectral centroid, sub/low/mid/high energy, detected pitch, onsets and tempo. Works on files outside the library too.
  • sample_libraryAdds or removes library folders and rescans changed files in the background.

Hears in numbers

The agent can’t listen, so it measures. It renders, reads the result, adjusts and renders again.

integrated
−14.1 LUFS
true peak
−1.0 dB
range
5.8 LU
onsets
64
  • renderRenders the song or a range of bars to a 48 kHz WAV and returns peak, true peak, RMS, integrated/short-term/momentary LUFS, loudness range, ten-band spectral balance, stereo correlation and onset times.
  • analyze_audioThe same measurements for any audio file, or a stretch of it.

Edits atomically, undoes cleanly

One tool changes the song: a list of typed commands applied as a single, all-or-nothing step.

  • edit_projectAdds and changes channels, sampler layers, patterns, notes, playlist tracks, clips, inserts, effects and sends. If any command fails, nothing changes and the error names the field.
  • get_summaryA compact overview: tempo, channels and samples, patterns, clips in bars, mixer.
  • get_projectThe exact song.json, or any part of it by JSON Pointer.
  • get_schemaTypeScript definitions of the model and every command, with defaults.

Finds what’s fighting in the mix

One stem per channel, measured against the whole.

  • analyze_mixEach source’s loudness and share of every frequency band, and masking: pairs that crowd the same band, like kick and bass at 60–120 Hz.

Masters to a target

Streaming at −14 LUFS, a club at −9 to −7: name the number.

  • masterRenders, measures and sets the master limiter’s input gain until the song is within 0.2 LU of the target, under a true-peak ceiling. Undoable like any edit.

Drives your plugins

Your VST3 and AU instruments and effects, by name, with every parameter.

  • pluginsLists installed plugins by name, maker, category, instrument or effect; scans for new ones.
  • describe_pluginLoads a plugin and lists its parameters with their values, so the agent can set them by name and automate them with automation clips.
  • list_effectsThe built-in eq, compressor, reverb, delay, phaser, chorus, lowpass and highpass, with every parameter’s unit and range.

Records your hardware

Per-track takes from a groovebox, landing on the grid.

  • recordSets the input device and sends MIDI clock so the hardware follows GrooveKit, calibrates the round trip once, then records every output into its own insert and playlist track. Silent takes are skipped; each take is levelled to about −20 LUFS.

Plays it for you

When it wants your ears, it presses play.

  • transportPlays the song or loops one pattern through your speakers, loops a range of bars, stops and moves the playhead.

Every change, on the record

Who changed what, and when. One request is one undo step.

  • undoReverts the last group of changes; edits made close together undo as one.
  • redoBrings them back.
  • get_historyThe full change history and the current position.

Works on your projects

The same project the app has open.

  • projectShows the open project and recent ones, opens another, creates a new one or saves a copy as. Your window follows.

The studio

A real DAW, not a chat window.

Everything the agent does, you can do by hand — and the other way round. Channels and patterns, a playlist of free tracks, and a mixer of inserts, effects and sends.

Channel rack & step sequencer

Every instrument is a channel. Click steps to program a beat, and the same notes open in the piano roll. One pattern holds notes for any number of channels.

Multi-layer sampler

Stack samples in one channel, each with its own key and velocity range, root note, gain, pan and envelope, one-shot or gated.

Mixer

Inserts with effect chains, faders, pan, sends and routing, all ending at master. Live meters while it plays.

Piano roll

Draw, move and stretch notes, and shape them in the velocity lane. It edits the same notes as the step sequencer, so a beat can grow into a melody.

Playlist

Free tracks that hold anything: pattern clips, audio clips and automation clips. Move, duplicate and mute clips, loop a range of bars; audio is time-stretched to the song’s tempo.

Sample browser

Your sample folders as a tree, and one search across tens of thousands of files by name, folder and category. Click to preview; drag onto the playlist or the channel rack.

  • PAT / SONG

    Loop one pattern while you build it, or play the arrangement. Space twice stops and goes back.

  • VST3 & AU plugins

    Instruments and effects in any channel or insert, with their own windows and automatable parameters.

  • Automation clips

    Draw curves for any mixer or effect parameter as clips on the playlist.

  • Render & master

    Bounce to a 48 kHz WAV, measure it, and master to a loudness target with a lookahead limiter.

  • History

    Every change from you or the agent, in order, with who made it. Undo and redo by request.

  • Projects as folders

    song.json, history, recordings and plugin states in one folder. Saved as you go; ⌘S and ⇧⌘S save as.

Built for hardware

Jam on the box. Let the agent arrange the takes.

Plug in an Elektron Digitakt II over USB, or any audio interface. Record long grooves by hand or ask the agent to — then let it cut, arrange, mix and master the takes like any other audio clips.

GrooveKit is the clock
It sends MIDI clock, start and stop, so the box starts with the song and follows its tempo.
Every output, its own track
Main, all 16 tracks and the Delay, Reverb and Chorus returns record at once, each into its own mixer insert and playlist track.
Takes land on the grid
Calibrate the round trip once with a few kick hits; every take after that is placed where it was played.
Ready to mix
Silent tracks are skipped, and each take’s clip gain brings it to about −20 LUFS, since hardware outputs arrive quiet.

Open source

Yours to read, change and build on.

GrooveKit is free software under the GNU AGPLv3: the engine, the app, the MCP server and the schemas. Your songs are plain JSON in a folder, described by a published schema.

AGPLv3, no strings

Use it for anything, including commercial music. If you ship a changed version — or serve one over a network — share its source under the same license.

Read the license

Build your own client

The engine speaks JSON-RPC over a local WebSocket: commands in, live patches out. A script, a controller bridge or another UI is a client like the app.

Engine API reference

Report bugs, request features

Found a bug or missing something? Open a detailed issue on GitHub: steps, what you expected, your setup. I follow up on every one. Pull requests aren't accepted, so the code stays consistent.

Open an issue

Build from source

Needs Xcode Command Line Tools, CMake, Ninja, Node 24+, pnpm and Rust. Full steps in the README.

git clone --recursive https://github.com/paulcpk/groovekit
cd groovekit
cmake --preset dev && cmake --build --preset dev
pnpm install && cd ui && pnpm app

Standing on

FAQ

Questions, answered.

Something else?Open an issue on GitHub.

What do I need to run it?

A Mac with Apple silicon and macOS 12 Monterey or later. Download the zip, unzip it and move GrooveKit to Applications.

macOS says it can’t open GrooveKit. What now?

The app isn’t notarized by Apple yet, so the first time macOS says it couldn’t verify GrooveKit. Click Done (not Move to Trash), open System Settings → Privacy & Security, scroll down to “GrooveKit was blocked” and click Open Anyway, then confirm with your password. After that it opens normally. Or in Terminal: xattr -dr com.apple.quarantine /Applications/GrooveKit.app

How do I connect Claude?

GrooveKit’s MCP server lives in the repository. Clone it, run pnpm install (Node 24 or later), and register the server with Claude Code: claude mcp add --scope user groovekit -- node /path/to/groovekit/mcp/src/index.ts. Check /mcp in Claude Code, then ask for a beat. When the app has the same project open (by default ~/Music/GrooveKit/Scratch; set GROOVEKIT_PROJECT for another), the agent works in your window and you watch every change happen.

Do I need the app to use the agent?

No, if you build the engine from source: when no app is serving the project, the MCP server starts its own engine, so Claude can build, render and master songs headless. Open the app on that project any time to see and play what it made.

Is the agent going to wreck my song?

Every agent edit is an atomic command in the project history. A request’s edits form one group, so a single undo takes the whole request back, and the Agent tab shows exactly what changed.

Where do the sounds come from?

From your own sample folders. GrooveKit indexes them in the background (tens of thousands of files are fine), describes each sound, and gives both you and the agent the same search. Your VST3 and AU plugins work too.

Does it cost anything?

No. GrooveKit is free and open source under the AGPLv3. You bring your own Claude access for the agent.

Windows? Intel Macs?

Not yet. The engine is cross-platform by design and a Windows build is on the roadmap, but today the app is built and tested for Apple silicon Macs.

How finished is it?

Early. The engine, command API, MCP server, sample library, analysis, mastering, live playback, recording, plugin hosting and a first desktop UI work. Expect rough edges, and please report them.

Make the next track together.

Free, open source, and on your Mac in a minute.

Download for macOSView on GitHub

Apple silicon · macOS 12 or later · All releases