← Selected work

A project by Jason Maitland / Listen

Calidaw

A music studio humans and agents can play together.

A native music workstation exploring what happens when a musician and an AI agent can inspect, compose and edit through the same underlying system. The result stays visible, playable and editable.

In practiceAn editable composition became a 53-second piece of music, with the complete mix preserved through Undo, Redo and independent reopening.

Private sourceActive development
Hear a piece made in Calidaw
Calidaw’s native arrangement view with instrument tracks, MIDI clips, named sections and an active playhead.View full size ↗
In the project

Sections, tracks and editable MIDI in the native macOS app. Development preview captured on 2 October.

About this image

Running application capture · 2 October 2026
Revision: Image 658a9b0f91fd

The problem

An agent can suggest a musical idea. Turning it into a useful part of a real session is harder: it needs to understand the instruments, preserve existing work, make deliberate changes and leave the musician in control.

What I built

A native studio with arrangement, MIDI editing, instruments, effects, playable racks and composition tools, connected by one musical model and a shared command system.

The interesting part

The interface and agent tools operate on the same notes, sounds and routing. An agent-generated phrase becomes ordinary editable MIDI; its changes can be inspected and undone in the app.

My contribution
Project creator responsible for product direction, the native studio experience and the shared musical system.
Evidence
Real native interfaces, saved multi-instrument sessions, reversible agent edits and music rendered by the application.
Access
Private source. Native macOS development preview; no public app download.
My decisions & how it was built
What I own
I connect the native studio, musical model and agent controls into one workflow, then use actual composition sessions to decide what needs to change.
A decision I made
I chose one validated command path for native controls and agents, so both preserve session identity, revision checks and ordinary Undo.
What it builds on
Calidaw has its own C++20 engine and project model, with native AppKit and UIKit hosts. Development is iterative with AI agents; Phrase Lab shares a JavaScript composition engine across its interfaces.

Listen to the result

Copperlight — Space & Motion

An original development study composed and mixed in Calidaw, rendered on 5 October 2026. Six instruments, editable MIDI, native effects and automation.

01 / The work

A musical idea, still editable.

Keep the musician in the loop.

I wanted to explore music software where an agent could do more than offer advice or hand back a finished audio file. Could it work on the same material as the musician—notes, clips, instruments and effects—and leave behind something worth developing?

That makes control part of the creative problem. A useful idea should survive outside a chat. A change should have a clear destination. And when an experiment is wrong, getting back should be an ordinary Undo.

A studio you can actually work in.

Calidaw grew from a native live looper into a larger studio: arrange clips, edit MIDI, build instrument sounds, route effects and mix a song. Desktop workspaces can split into different views or open in peer windows while sharing the same session.

The application has its own C++ audio engine and musical project model. The Mac interface uses native controls; composition tools sit alongside the timeline and instruments. Saving the project preserves the musical objects, rather than relying on the conversation that created them.

One musical system. Several ways in.

A person can turn a control in the interface. An agent can discover that control, read its current value and request a change. Both reach the same validated command path, with the same musical identities and Undo behaviour.

An agent first discovers what the running application supports. Changes name their target session and expected revision, so a delayed request cannot quietly edit a different song or overwrite a newer decision. Each applied operation returns a receipt; retrying the same operation does not create a second copy.

This is also an interaction-design choice. The visible application remains the place to inspect and continue the work. The agent does not own a parallel version of the song.

From a phrase to editable music.

Phrase Lab is a shared composition workspace for harmony, motifs, runs, gestures and layered parts. A seed makes a generated idea reproducible; locks and explicit destinations help preserve what already works.

The visual editor and native agent access use the same deterministic engine and draft. A phrase can be previewed and planned before becoming MIDI clips and an optional named section in the song. Applying it is one musical Undo.

The recipe and the result serve different purposes. MIDI is the material a musician edits; the recipe retains the choices that produced it. Keeping those separate makes it possible to develop a phrase without pretending every manual edit is still generated.

Make the sound understandable.

A long list of parameters is technically complete and often musically unhelpful. I have been replacing that starting point with instrument-specific surfaces: a string model exposes contact and resonance; other instruments make their own sound-shaping relationships visible.

Racks bring instruments, effects and modulation into one saved structure. Their front, back and mixer are different views of the same graph. Turn the rack around and the connections are explicit, including note signals and one device modulating another.

The newer sound palette starts with an editable sound and a separate musical example. Directions such as warmth, bite and movement resolve to inspectable parameter changes. Audition and A/B comparison happen before applying a candidate to the song.

The integration test is a piece of music.

Copperlight began as a 24-bar study with six instruments, editable patterns and a five-section arrangement. Space & Motion is a separate mix that adds room, hall and echo returns, track treatment and section-aware automation.

The 53-second output below was rendered by Calidaw. The underlying notes, sounds, routing and automation remain editable. It is a development study, and a more useful demonstration than an empty editor or a list of implemented features.

The technical checks include restoring the complete mix with Undo and Redo, reopening the saved project independently, and rendering without clipped samples. Those checks matter; the musical result is something to hear and judge.

Playback is not the same as a good piece.

Using the application to compose exposed problems that isolated feature tests did not. A song could contain the right notes and still feel repetitive. An agent could report successful playback without having evaluated the result. A sound editor could expose every control while making the important ones hard to find.

That pushed the work toward motif development, deliberate arrangement, clearer sound controls and explicit listening comparisons. It also changed the way I evaluate progress: source tests, a running application, a saved song and a musical judgement answer different questions.

The next work continues that loop: improve the tools, make something with them, inspect what happened and let the result challenge the design.

Two collaborators, one musical project

The interface is a way in.

A person can edit a part directly. An agent can propose the same kind of edit through a structured tool. Both return to the same musical state.

Human

Native workspace · Phrase Lab

Agent

Inspect · preview · apply

Shared musical commandsIdentity and revision checks · receipts · Undo

Project model

Notes, clips, instruments, routing and automation

Prepared audio engine

Playback and rendering, separated from control work

Conceptual architecture. Model inference and storage stay outside the audio callback; an agent's edits remain ordinary project material.

How it connects

One project, shared control.

The native interface and agent tools meet at the same musical boundary.

  1. 01

    Choose an entry point

    Native interface, Phrase Lab or a connected agent. Discover the tools and inspect the current song.

  2. 02

    Make a guarded edit

    Validate the target and revision, preview when useful, apply once and retain an ordinary Undo.

  3. 03

    Hear and continue

    The shared project drives playback and rendering. Inspect the result and keep editing the same musical material.

Audio execution stays separate from control requests. External agent access is optional; the built-in studio and composition engine run locally.
Diagram source

Implemented architecture and workflow · reviewed 6 October 2026
Source revision: Reviewed against project evidence

03 / Choices & trade-offs

The decisions that shaped it.

01

Own the musical model

I retained the existing C++20 engine and native adapters after evaluating other frameworks. That preserved the working project, timing and command model; it also leaves me responsible for the remaining audio and platform engineering.

02

Share the command path

Native controls and agent access use the same validation and Undo semantics. Adding a second automation-only edit system would make it harder to know which state was authoritative.

03

Generate editable material

Composition tools create normal notes and clips. Recipes remain separate, so generative intent can be reused without making the resulting music untouchable.

04

Keep audio work local

The engine, built-in instruments and deterministic composition tools do not require a hosted model. Optional external agent connections have their own explicit boundary.

04 / Iteration

What changed along the way.

  1. Foundation

    Capture and keep a loop

    The initial native slice concentrated on quantized capture, retained overdub layers, playback and recoverable session data.

  2. Studio

    Turn one device into a working session

    Arrangement, MIDI, clip performance, mixing and flexible native workspaces extended the same underlying musical model.

  3. Composition

    Give humans and agents the same draft

    Phrase Lab introduced deterministic generation, explicit destinations and reversible insertion into the song.

  4. Current work

    Let real music drive the next iteration

    Agent-authored sessions, playable racks and sound-shaping experiments now expose the gaps between a functioning feature and a useful creative tool.

05 / Under the hood

For the curious.

Architecture, implementation and the details behind the interface.

Native hosts, shared engine

A C++20 core owns musical execution. Native hosts prepare and publish changes; AppKit handles the Mac interface. The iPhone work uses UIKit. A complete Linux application remains a separate delivery target.

Keep control work away from the audio callback

Graph preparation, allocation, storage and analysis belong outside real-time audio processing. Incoming edits are validated and prepared before the engine applies them at an appropriate boundary.

Discover, inspect, change, verify

Typed capabilities describe valid targets, parameters and units. Session identity and revision guards protect edits; operation receipts make retries and result inspection explicit. MCP adapts this contract for agent clients.

One deterministic composition engine

Phrase Lab runs the same repository-owned JavaScript in the embedded browser surface and native JavaScriptCore. The installed tool needs no Node runtime or hosted composition service.

Save the music, preserve the experiment

Native songs retain their musical structure and device state. Separate recipe and draft data retain generative intent. Independent reopen and complete-state comparisons test persistence beyond a successful Save dialog.

Explore the current capability map & roadmap

From an idea to a playable session.

These tools are implemented in the internal Mac preview. The project is still being tested as a complete studio, with musician, device and platform acceptance continuing.

Record & loop

Record audio tracks with monitoring, count-in, metronome, punch and loop recording. Build multitrack live loops with independently sized loops and retained overdub layers and per-track Undo; select alternate takes and recover interrupted recordings.

Compose & arrange

Edit audio and MIDI arrangements, transform notes in a piano roll and develop reusable instrument clips in Phrase Lab. Section harmony, quantized clip and scene launching, and editable performance capture connect composition with playing.

Instruments, drums & sampling

Play built-in synths and a sampler, shape modeled, synthesized or sample-based drum sounds, and work in Guitar Studio. Instrument-specific controls keep sound choices close to the part being played.

Playable modular racks

Use Front, Back and Mixer views to patch audio, notes and controls. Connect modulation sources, mix inside a rack and save complete reusable rack presets.

Mix, automate & compare

Set gain and pan, inserts, sends and buses; add automation and modulation. Preview track, master and stem renders, inspect audio measurements and compare matched A/B candidates with reversible checkpoints.

Editable AI work & project recall

Use flexible desktop workspaces, managed project saves and migration, and a local agent API with guarded edits, receipts and grouped Undo. Authenticated ChatGPT integration is still being qualified.

Where Calidaw is going.

Planned and in-progress work, reviewed against the project roadmap on 5 October 2026. These features describe the intended studio; they are not all available in the current preview.

Recording & audio editing

Richer take lanes and comping, calibrated recording alignment, pitch-preserving time stretch and seamless loop workflows. A dedicated Audio Editor, local media Browser, fuller sampling workflows, meters and analysis extend the production workspace.

Arrangement, mixing & finishing

Tempo and time-signature maps, deeper routing qualification, freeze, stem and effect-tail workflows, and consistent project recall across the complete production journey.

Expressive MIDI & performance

MPE and wider note expression, contextual groove and ensemble transformations, reversible editing recipes, named clip and loop variants, advanced performance capture and foot/controller workflows.

Build & share your own devices

A dedicated Build workspace for text- and AI-assisted instruments, effects and MIDI processors. Versioned portable device packages would carry resources and declared capabilities, extending the playable racks already in the preview.

Native plugins & a standalone looper

Third-party plugin hosting and independently installable standalone and plugin looper releases. AU, VST3 and CLAP on desktop, and AUv3 on Apple mobile, are proposed qualification targets.

Two-deck DJ workflows

Prepare and perform with beatgrids, cue outputs, key and tempo controls, controller integration and explicit clock handover between performance tools.

Deeper AI creation & sound design

Visible task progress, human intervention and task-shaped composition guidance, editable starter sounds, semantic sound controls, constrained variations, isolated candidate comparison and reference-guided exploration. An optional local listening assistant remains dependent on passing controlled evaluations.

Video Studio

An integrated editor with media bins, import and relink, proxies, source/program views, precise timeline trims, nested sequences and basic retiming. Plans include compositing and keyframes, managed SDR colour and scopes, editable titles and manual captions.

Video production & delivery

Production sound, four-angle multicam, queued exports and documented timeline interchange. Advanced motion, keying, retiming, HDR and optional local transcription assistance and Linux/iPad/iPhone video workflows belong to later qualification stages.

A portable native studio

Complete music workflows on macOS, Linux and iOS/iPadOS, with touch layouts, offline core use, accessibility, recovery and real audio/MIDI/controller testing. Human musical acceptance remains part of finishing the product.

06 / Current state

Where it stands.

What exists today

An actively developed macOS preview, with native iPhone work and a portable engine. Wider device testing, support for other platforms and external plug-ins are still underway. The source and application builds remain private.

Where I’m taking it

  • Continue refining composition and sound shaping through actual songs and listening comparisons.
  • Expand instrument and rack coverage in the shared sound workspace.
  • Test recording and playback with more physical devices, and continue work on other platforms and external plug-ins.
  • Make newly added native tools consistently available through connected agent clients.

Another thread to follow

Continuum

A project should remember why.

PRISM

Local agents. Work you can inspect.

Have something like Calidaw in mind?