Composure is a MIDI engine with sixteen channels, four of them named. That sentence is worth sitting with, because almost everything written about this app so far — including, for a while, by us — describes five.
The correction matters more than a number. The earlier version of this piece said Composure had five channels: Drums, Lead, Melody, Ambience, Bass. That is not what the code says. It has never been what the code says. The real map lives in a single file called channelMap.ts, and it reads like this: sixteen channels total. Four carry default roles, sitting on channels one through four — Drums, Bass, Chords, Melody. Channels five through sixteen are open. Unnamed. Waiting.
There is no Lead role. There is no Ambience role. Those were invented to make the product sound tidier than it is, and they made it sound smaller, too. A five-lane box is a thing you fill. A sixteen-channel map with four names and twelve blanks is a thing you grow into — and it tells you what the designer actually believed: that the interesting part of a music tool is the part you haven't assigned yet.
Voices, not tracks
The old piece leaned hard on the idea that a song is a stack rather than a sequence — true enough, but it's the kind of thing you say when you haven't opened the app. The more useful distinction is the one the interface actually enforces.
A track in a digital audio workstation is a container. It holds clips, and clips hold events, and the events sit at positions along a timeline. You edit by moving things around on that line. A channel in Composure is not a container. It is a voice, and it exists for the entire duration of the piece whether or not it is sounding. When the agent changes the bass, it is not editing a region of a timeline. It is speaking to one voice and leaving the others alone.
That is the whole trick, and it is the reason the app can be handed to a model at all. Modify one, the rest hold. No re-roll. No regenerating the song and hoping the parts you liked survive. You name the voice, you say what should change, and the other fifteen channels do not move.
And the unit of work is not a file. It is a session. That distinction sounds academic until you use it: sessions can be listed, opened, edited and played back by something other than you — which is the next part, and the part that every previous write-up missed entirely.
Two agents, one instrument
Composure is agent-native in both directions, and this is the single largest thing the earlier coverage failed to mention. There are two separate agent surfaces, and they reach the same engine.
The first is a Model Context Protocol server, bundled with the desktop app, speaking JSON-RPC over Streamable HTTP on localhost port 9473. It exposes sixteen tools — and the list is worth reading in full, because the list is the product:
- play_midi, stop, get_playback_state — transport
- modify_playback — change a performance that is already running
- play_session, list_sessions, get_session, update_session, save_current — the session archive
- get_channel_map, update_channel_map — the map itself is writable
- soundscape, drum_forge, synth_forge, create_mood — generation
- status — what the engine is doing right now
Read the middle of that list again. An outside agent can program drums, build a synth patch, generate a soundscape, author a mood, and modify a performance while it plays. It can rewrite the channel map. It is not being handed a prompt box with a music-shaped lid on it. It is being handed the instrument.
The second surface is internal. Inside the app lives Muse, a working agent with its own tool set — twelve of them: playMidi, stopPlayback, saveCurrent, getPlaybackState, modifyPlayback, playSession, updateSession, updateChannelMap, createMood, updateSoundscape, updateDrumForge and updateSynthForge. Which means the same engine answers to a model sitting on your desktop and a model living inside the window.
The agent does not get a prompt box with a music-shaped lid on it. It gets the instrument — play, stop, modify, generate, rewrite the map. — Studio Notes, Composure Design Log
What is actually in the box
Here is where the old description failed most completely. It described a sketchbook and a tablet and a nice idea about channels. It never opened any of the rooms.
Composure ships with eleven rooms in the sidebar and three more reachable from inside it — fourteen views in the app's own state model. The previous version of this page settled on "thirteen," which matches neither. What matters is not the tally. What matters is that each room is a real, finished instrument, and several of them are things I have not seen anywhere else.
Soundscapes — a generative engine, not a preset list
Four thousand lines of ambient synthesis on Tone.js, driven by fourteen moods: Joy, Dark, Mystic, Deep, Calm, Sad, Tense, Sweet, Cinematic, Ethereal, Warm, Cosmic, Meditative, Dreamlike. Each mood isn't a filter setting. It's a parameterized frame that shapes pattern generation across seven modes — drone, arpeggio, strum, pulse, random, percussion and melody — under a voice ceiling. You author a mood, you don't select one.
Synth Forge — and a Chladni visualizer
Nearly four thousand lines and sixty-seven pieces of state: a full synthesis workbench. Around thirteen hundred of those lines are a visualizer that renders Chladni patterns — the standing-wave figures that appear when you bow a plate of sand. The picture is generated from the sound of your patch. Change the sound and the geometry moves.
Radio — and yes, it really does generate music live
The internet radio is the largest single file in the app, and it is not a stream player. Alongside the stations sits a station graph and a 3D pearl visualization — a spherical particle orb with a perspective terrain mesh, bloom compositing, ripples, rising particles, oscilloscope waveforms and emissive haze columns. Five named render layers, in a radio.
More significantly: the radio instantiates Lyria, Google's realtime music-generation model, so it can produce audio on the fly rather than only play what already exists. An earlier draft of this piece described Lyria as "a secondary option — a tool inside a tool." Having now read the module, that undersells it. It is an active model binding inside the app's biggest component.
Sheet music — written from scratch
This is the one that genuinely surprised me. Two thousand two hundred lines of notation engraving, and it is not VexFlow, not OpenSheetMusicDisplay, not abcjs. It is hand-written, drawn onto a canvas, and it handles real engraving problems:
- Key signatures and courtesy accidentals — the reminder sign a careful engraver puts in when a note's accidental carries over from the previous bar
- Tied notes across barlines, with the arcs drawn in the correct direction for each voice
- Beam grouping that respects the beat, hairpins for crescendo and diminuendo, fermatas, and 8va spans
- Independent treble and bass staffs
The old piece mentioned sheet music twice, in passing, as a nice thing a violinist could read. The truth is that someone sat down and wrote a music engraver. Most notation software is built on a library that took years to write. This one was written in-house, in TypeScript, on a canvas.
The rest of the bench
- Drum Forge — a step sequencer and sample engine, twenty-five hundred lines, playable by hand or by an agent.
- Basic Pitch, on-device — hum a line and it becomes MIDI at 22.05 kHz, offline. No upload, no cloud round trip. The fastest path from head to mutable object that exists in the app.
- Knowledge Graph — nineteen hundred lines mapping sessions, ideas and their relationships.
- Dungeon Master — a quest engine that hands the instrument a brief, so it can collaborate on something other than your last idea.
- Sketch — a drawing room. Because the idea arrives before the notes do.
- Vault — sessions, patches and audio in one searchable archive. The archive is the instrument.
- Composer — the notation view, which is really the room where the engraver lives.
Two claims from the previous version of this page do not survive contact with the source. The first: that any session exports to Obsidian as a markdown note with the MIDI embedded. It does not. There is a vault-path field in Settings with a Browse button beside it, and neither one is wired to anything — the field has no change handler, the button has no handler, and there is no markdown writer anywhere in the codebase. The second: that there are thirteen rooms. There are eleven in the sidebar, fourteen in the app’s own view state, and thirteen in the copy. One of those numbers was invented.
What it does with your hands
Three integrations matter more than any feature list, and all three were absent from the previous write-up.
It talks to your DAW, on the clock
Composure opens a virtual MIDI output and runs a MIDI clock at 24 pulses per quarter note, with proper start and stop messages. That is the real thing, not a novelty: a DAW slaved to that clock will follow Composure's tempo, and the tool descriptions in the source name Maschine, Ableton and FL Studio as the intended destinations. Separately, MidiContext handles hardware MIDI both ways — inputs, outputs, device selection, and it remembers your device by name across sessions.
So the sketch doesn't end in the sketchbook. It arrives in the session you're already working in, on the grid, in time.
Your humming becomes notes, locally
Basic Pitch runs on-device at 22.05 kHz. You sing a line, it becomes MIDI events, they land in the session as editable data. Offline. Nothing is uploaded and nothing round-trips through a server. This is the shortest distance between the idea in your head and an object you can modify, and it is a genuinely rare thing to find implemented locally.
The tablet is a controller, not a companion app
The Android build is a remote MIDI controller over your own local network. The desktop runs a sync server on port 19319 and exposes routes for info, manifest, sessions, audio, patches, handshake, API keys and a controller relay. A WebSocket carries control events back; the desktop routes them straight into local playback.
Which means the tablet on your music stand is not showing you a read-only mirror. It is an input surface for the instrument on the desk — the thing you reach for while both hands are busy.
What it does not do yet
This section did not exist before, and it should have. A product page that only lists strengths teaches the reader to distrust it.
- Obsidian export is not wired. There is a settings field for a vault path and a Browse button beside it, and neither does anything — the field has no change handler and the button has no handler. Nothing writes a markdown file. The idea is clearly intended; it is not implemented. We are leaving the claim off the page until it is.
- No Bluetooth stack. As above. Local network and OS-paired MIDI only.
- The "Scribe Active" indicator is cosmetic. It is hardcoded in the sidebar and does not reflect state. The real feature underneath it — silent MIDI capture on startup — is a genuine setting and does work. The lamp is just always on.
Three honest limitations cost less trust than one discovered overstatement. That is the whole reason this page was rewritten.
Sixteen channels, four of them named. Sixteen tools on one side of the wall, twelve on the other. The rest is left open on purpose. — Studio Notes, Composure Design Log
Why this is worth your attention
The interesting thing about Composure is not that it makes music with a model. Plenty of things make music with a model.
It is that the instrument was designed from the beginning as something a non-human could play — and not as a novelty. The channel map is writable by an agent. The session archive is readable and editable by an agent. A performance in progress can be modified without stopping it, by something that is not you, without disturbing the other fifteen voices. Those are not features bolted onto a sketchpad. They are the reason the sketchpad was built the way it was.
Most tools in this category treat generation as a one-shot act: you prompt, it produces, the output is sealed, and if the bassline is wrong you regenerate everything and hope. That is the timeline metaphor applied to AI — the model is a track, and you keep the track or you don't.
Composure took the other road. Voices persist. The agent edits one and the rest hold. And underneath all of it sits a hand-written music engraver, a Chladni visualizer driven by your patch, fourteen moods you author rather than select, a radio that can generate what it plays, and an archive that keeps every session you have ever made.
That is not a sketchbook with an AI feature. That is an instrument with a collaborator, and the collaborator was in the design from the first file.
Composure is built by Propagation House. This page was rewritten after a full read of the source — every claim above carries a file and a line number behind it, and the corrections are stated rather than quietly dropped.
