Blokkily, an experimental pattern-based DAW, adds MCP control for AI agents
Blokkily is an experimental pattern-based digital audio workstation (DAW), presented through its repository README. The core idea is that one pattern can be edited in three synchronized views, a tracker, a piano roll or a step grid, and patterns are then arranged across multiple tracks. It supports CLAP and VST3 plugins, SoundFont instruments and built-in samplers, and CLAP support is required in every build.
The AI angle is twofold. An LLM composition assistant can be asked for a phrase; the README tells users to review its proposal before applying it, and each generation counts as one undo step. Separately, an MCP bridge lets agents control the running application. The README links a short video, with sound, of an agent building a funky chiptune in Blokkily over MCP using the YANES and FUZZBOI CLAP synths. Setup, tools and environment variables for MCP, and the assistant's backends and reply format, are covered in separate documents that this README only points to.
Beyond that, the feature list is that of a conventional DAW. Patterns support inversions, strum, microtiming, probability, ratchets, loop conditions and parameter locks, and edits are heard during playback without stopping it. The arrangement is a multi-track timeline with named patterns and audio clips, tempo steps, ramps and meter changes, and a scene launcher for performing patterns live and recording the performance into the arrangement. Input comes from a MIDI controller or the on-screen piano, isomorphic grids, fretboards and chord pads, with scales and tunings that include microtonal options. The mixer offers inserts, sends, returns, sidechains, auxiliary outputs, automation and modulation. Users can record audio and MIDI, resample a bus, bounce stems, export the arrangement as 16-bit, 24-bit or 32-bit float WAVE, and import and export Standard MIDI Files.
To build it you need Qt 6.5+, plus FluidSynth, RtAudio, RtMidi, libsndfile, libsamplerate and Rubber Band 4, found through pkg-config. The verification tests also need a SoundFont. JUCE and the CLAP headers are vendored under third_party/. The build uses CMake with Ninja, and a headless scheduler demo is available as blokkily_cli.
The README is open about the limits. Blokkily is experimental. Comping and MIDI clock input are not implemented. MPE support varies by instrument format, and per-note expression has no editor. Large unwarped audio clips can stream from disk, but warped clips and sampler samples still load into memory. Native plugin-window pixels require an X11 display. Export always renders the arrangement, so a launcher performance must be recorded into it before exporting.
On licensing, clip warping links the Rubber Band Library, which is licensed under the GPL (version 2 or later) unless a commercial licence is bought from its authors, so a Blokkily binary built with it is subject to the GPL. The bundled IBM Plex Sans and JetBrains Mono fonts are under the SIL Open Font License 1.1.
Key facts
- Blokkily is an experimental pattern-based DAW: the same pattern can be edited in a tracker, a piano roll or a step grid, three synchronized editors.
- It supports CLAP and VST3 plugins, SoundFont instruments and built-in samplers; CLAP support is required in every build.
- An MCP bridge lets agents control the running application, and a short demo video shows an agent building a chiptune with the YANES and FUZZBOI CLAP synths.
- An LLM composition assistant proposes phrases that the user reviews before applying; each generation is one undo step.
- Known gaps include comping and MIDI clock input, which are not implemented, and an X11 display requirement for native plugin-window pixels.
Why it matters
Blokkily exposes the whole running application to agents through MCP, so an agent can build a piece in the same editors a human uses, and the README shows this with a chiptune built over MCP. It is a small, experimental project, so it matters as an example of the pattern rather than as a market event: a DAW designed so that an agent and a person can work on the same pattern.
Who it affects
Hobbyist and experimental music makers who like tracker, piano roll and step grid workflows, and developers who want to try agent-driven composition against a real plugin host. Anyone who wants to build it needs to be comfortable with a C++ toolchain, Qt 6.5+ and several audio libraries.
How to use it
Build from the repository. You need Qt 6.5+, plus FluidSynth, RtAudio, RtMidi, libsndfile, libsamplerate and Rubber Band 4 found through pkg-config; the verification tests also need a SoundFont, and JUCE and the CLAP headers are vendored under third_party/. The commands are cmake -S . -B build -G Ninja, cmake --build build, and ctest --test-dir build --output-on-failure. The build produces the blokkily application and a blokkily_cli headless scheduler demo. The README points to separate guides for usage, MCP setup, the composition assistant and verification.
How solid is it
The README calls the project experimental and lists its limits itself. It states no benchmarks, user counts or performance figures, and the claims about the MCP bridge and the assistant rest on the README and a linked demo video. The README mentions repeatable BDD, integration, end-to-end and screenshot verification checks and a ctest run, but this retelling has not run any of them.
Risks and caveats
Comping and MIDI clock input are not implemented, MPE support varies by instrument format, and per-note expression has no editor. Warped clips and sampler samples still load into memory. Native plugin-window pixels require an X11 display. Export always renders the arrangement, so a launcher performance has to be recorded into it first. The README says to review the assistant's proposal before applying it. On licensing, a binary built with the Rubber Band Library is subject to the GPL unless a commercial licence is bought from its authors, and the README states no licence for Blokkily's own code.
“An MCP bridge also lets agents control the running application.”
— Blokkily README