Roadie · the command palette

Type it. See the plan. Press Enter.

One key press brings it up over your music software. Type what you want, read the plan, press Enter.

Roadie is a helper that sits beside your music software, in the lineage of Spotlight and Raycast. Press one key and a small window opens above your session. Type what you want — a command, a fragment, or a plain sentence — and Roadie turns it into a plan you can read before anything happens. Anything risky is previewed first, everything goes through your software’s own undo, and nothing destructive runs without you seeing it. Ableton Live 11 and 12 are the first hosts.

On sale · specified in RDE-SPEC-001 v1.0
Roadie 1.0a small app for macOS and Windows that sits beside your music software, not inside it; Ableton Live 11 and 12 come first
⌥ Spacethe global hotkey — the window is up before you could notice it loading
> ask Roadiethe optional assistant: it suggests a plan in your own words and never acts — Roadie works in full with it switched off
118.004 / 41 BAR▶ ■ ●SESSION1 Drums2 Bass3 Keys4 Vox Lead5 Pad Layer6 FXA ReverbtrackbaescMute Tracktrack Bass↵Solo Tracktrack BassArm Tracktrack BassRename Tracktrack Bass → name▮Track: Bass BackupselectDETAILBass · MIDI · armed · vol −6.0 dB · 2 devices · sends A 0.30Will run: mute_track(track_index=3, mute=true) tier 1LOG✓18:42:03 set_tempo 124✓18:41:50 launch_scene 7Ableton Live 12.1 · ClaudeMCP_Remote · 9004AI ready · undo 41234
Mock UI — redrawn from the Roadie specification’s own wireframes, not a screenshot of the shipped app. Values are illustrative, not measured. Figure 6.1: ① the input line with a scope chip and the caret, ② the ranked results with their argument summaries, ③ the detail pane with the plan Enter will run, ④ the log strip; the status bar under them names the host, its script and the AI layer’s state.
16 msHotkey to palette

key-down to the first frame presented, p95, a 1.0 gate

178Built-in commands

43 queries · 79 at tier 1 · 42 previewed · 14 destructive

220Live actions on the wire

the ableton-liveapi-tools Remote Script, JSON over TCP on port 9004

83 %Want to see the plan first

of 412 respondents; 11 % would accept an assistant that acts unseen

What it does

Nine things, each written down.

Each one is a requirement in the book with a stable identifier, and each carries the limit the book states beside it. They are the book’s requirements, and the product is on sale.

01

Deterministic before probabilistic

A typed command resolves the same way every time: exact and alias first, then a fuzzy layer with a published threshold and frecency, then the object by name. The AI layer is only asked when those decline, or when you prefix the request with >.

The limit:Layers 1 to 3 must run offline, and the fuzzy threshold and weights are constants in the grammar, not tunable per user (GR-001, GR-002). Proposed

02

Nothing destructive runs unseen

Every action carries a risk tier from 0 to 3. Tier 2 shows a preview and runs on Enter. Tier 3 needs ⌘↩, a chord no other confirmation uses, shows the undo prediction in red, and is never batched, even inside an AI plan.

The limit:A tier 3 confirm within 300 ms of the preview appearing is ignored, to defeat key repeat and a double press (KB-031). Proposed

03

The host owns undo

Roadie keeps no undo stack of its own. It drives the host’s undo and redo, records the host’s undo depth before and after every plan, and so can say how many steps “undo last plan” will take before it takes them.

The limit:The Live script does not report undo depth, so the adapter keeps a shadow counter and warns when the user has edited in the DAW since the plan ran (UX-072). Proposed

04

Ask in plain language, get a plan

Prefix > and Roadie builds a compact description of the session, asks a language model for a plan in Roadie’s own action vocabulary, grounds every index against the snapshot, and shows the plan before anything runs. Accept it, edit it in the input line, or save it as a macro with your words as its alias.

The limit:Remote, local or off, and which is the default is an open question (Chapter 20); the palette must work fully with it off (AI-040). A preview within 2.5 s at p75 with the remote provider; a 6 s timeout falls back to the grammar. Proposed

05

A log you can teach from

Every executed plan is written in the command grammar with its timestamp, its outcome and the host’s undo depth. Open it as a view, export it as text or JSON, re-run any entry with one key, or hand it to a class as the handout.

The limit:The log lives in memory for the session and reaches disk only when you export it; nothing project-specific is written otherwise (Chapter 17, session data). Proposed

06

Performance mode

For the stage: type 25 % larger, the high-contrast palette, no detail pane, log strip or status bar, and tier 3 commands hidden unless you type the full name and a ! suffix. The palette waits for Escape after a result so you can glance down and confirm.

The limit:Toggled from the palette or the menu bar and persisted across restarts (UX-080); the ! suffix is an open question the stage checklist will settle. Proposed

07

Queries, not only commands

Prefix ? and Roadie reads instead of writing: ? frozen tracks runs one read per track and renders a table you can arrow through, with a row count, and copy as tab-separated text with one key.

The limit:Queries are tier 0 and never change state; a plan made only of tier 0 steps renders as a result, never as a preview. Proposed

08

Extensions in a text editor

A macro is a JSON file: a name, aliases, typed arguments and a list of steps. A scripted command is a function in a sandbox with no file, network or process access. The roadie-sdk tool checks a folder and runs a command against a recorded snapshot before you ship it.

The limit:No store, signing or review in 1.0; sharing is copying a folder. A script is limited to 200 ms and 16 MB, and its steps pass the same validator as an AI plan (SDK-010 to SDK-012). Proposed

09

Local by default

The grammar, the matching, the session snapshot and the adapter run on the machine. Only the AI layer may make a network request, only when you have configured a remote provider, with a visible indicator in the status bar and the menu bar while one is in flight.

The limit:Provider keys live in the OS keychain, never in a settings file; telemetry is opt-in and carries no input text, no names and no plan contents (SC-020, SC-030). Proposed

How a keystroke becomes a plan

Five stages. One side branch.

The grammar, the validator and the policy are the same for a typed command, a macro and an AI plan: the planner is a side branch that feeds the validator, never a path around it. Every budget on this page is a 1.0 gate, measured on a 2020 laptop-class machine with a 24-track session.

01InputThe hotkey shows the palette with the zero state: up to three pinned commands, the five most recent for this host, and up to three suggestions drawn from the cursor.UI thread · never blocks
02GrammarThree deterministic layers on every keystroke: exact and alias, fuzzy with a 0.45 threshold weighted 0.75 match to 0.25 frecency, then the object. Rows within 16 ms of the key.Engine thread · pure, no I/O
03AI plannerThe side branch, taken only when the layers decline or you prefix >. A compact context under 8 KB, a plan in the action vocabulary, one clarifying question at most, nothing it can execute itself.AI thread · cancelled on Escape
04ValidatorEvery step against its action schema and the host’s capabilities, every index grounded in the snapshot, at most 32 objects unless you said all or every. A step that fails is shown, never dropped.Engine thread
05PolicyThe plan’s tier is its worst step. Tier 0 and 1 run and are logged; tier 2 previews; tier 3 waits for ⌘↩, each step confirmed on its own.Engine thread
06AdapterOne JSON object per request over TCP to the Live Remote Script, one request in flight at a time, a typed error with a stable code on failure, a 2 s timeout.Adapter thread · the only blocking I/O

The eight principles, in order

When two conflict, the earlier one wins.

#PrincipleWhat it commits Roadie to
1Never surprise the hostEvery action maps to a known host operation with known side effects; every risky action is previewed; every plan reverses through host undo. When Roadie cannot tell what a request will do, it asks rather than guesses.
2Keyboard first, mouse never requiredEvery state is reachable with the keyboard alone. The mouse is a convenience, never a requirement: no hover-only affordance, and Enter and Escape are always meaningful.
3Deterministic before probabilisticA typed name always resolves to the same command; the AI layer is asked only after the deterministic layers decline, and answers in the same vocabulary.
4Show the planWhen Roadie does something non-trivial, the user sees it in terms they could have typed. No hidden state, and the log is a first-class part of the interface.
5Invisible until summonedNo persistent window, no dock presence beyond a menu bar icon, no notifications that interrupt. The palette appears when called, on every monitor, over every DAW window, in under a frame.
6One frame to feel nativeThe hotkey-to-visible budget is one frame at 60 Hz. A layer that cannot meet its budget degrades rather than making the user wait.
7The host’s vocabulary, not oursA scene is a scene, a return track is a return track, a take lane is a take lane; a host-specific command is offered only when that host is connected.
8Extensible by the people who need it mostA documented extension model, so a drummer’s live looping rig or a studio’s routing presets can be built without waiting for the core team.
On stage

Two states that matter in a dark room.

A destructive command never runs on Enter alone, and never within 300 ms of its preview. On stage the palette drops everything but the input and the result, and keeps tier 3 out of reach unless the full name and a ! suffix are typed.

FIGURE 6.4 · TIER 3 PREVIEWtrackdeleteBass⌘↵ to delete⊘Delete Tracktrack · Bass (3)destructivePREVIEW · TIER 3 · 1 STEPdelete_track track_index=2 (Bass, #3)undo: 1 step · removes 4 clips, 2 devicesBass · MIDI · 4 clips · 2 devices · sends A 0.30 · not frozenesc cancelFIGURE 6.7 · PERFORMANCE MODEscene 27↵▷Launch Scene27 · Breakdown BNo detail pane. No status bar. No log strip.Tier 3 is hidden unless the full name and a ! suffix are typed.Waits for Escape after a result, so you can glance down.
Mock UI — redrawn from the Roadie specification’s own wireframes, not a screenshot of the shipped app. Values are illustrative, not measured. Left, Figure 6.4: a tier 3 preview, the detail pane forced open, the undo prediction in the danger colour, and a confirm hint that names the chord. Right, Figure 6.7: performance mode, 25 % larger type in the high-contrast palette, one row, nothing else.
The keys

Every behaviour, from the keyboard.

macOS chords are shown; on Windows ⌘ is Ctrl throughout. Every chord is remappable from /keys and checked for conflicts, and Escape always makes progress toward hidden: no state may trap the user.

The key map

ChordAction
⌥ SpaceShow or hide Roadie
EscBack · clear · hide
↩Run, tier 0 to 1 · confirm, tier 2
⌘ ↩Confirm destructive, tier 3 · run and keep open
↑ ↓Move selection
⇥ / ⇧ ⇥Next or previous argument slot · accept completion
⌘ KAlternatives for the selected object
⌘ DToggle the detail pane
⌘ LLog view
⌘ Z / ⌘ ⇧ ZUndo last plan · redo
⌘ 1 … 9Run result N
⌘ CCopy input · plan · result
⌘ ,Settings
⌘ ⇧ PPerformance mode

Scope keywords

KeywordRestricts results toExample
trackTrack commands and track objectstrack mute bass
clipClip commands and clip slotsclip launch bass 3
sceneScene commands and scenesscene 12
devDevice commands and devicesdev reverb decay 2.4
send · retSends and return trackssend bass a 0.4
?Queries, tier 0? frozen tracks
>Ask Roadie: the AI layer> mute everything but drums
/Settings and Roadie’s own commands/keys

The reference tokens: . is the cursor object, #3 an index (1-based, as the DAW shows it), last the object most recently created in this plan, all every object (which raises the scope limit), and ! allows a tier 3 command in performance mode.

Who it is for

Five people, seven jobs.

The personas and the jobs they were consolidated into are the book’s; the figures under them are the research it cites, and are tagged Reported.

the in-flow producer

Maya

Make the common five-step setups one command. Let her type tempo 124 and have it happen. Never make her look at a dialog.

Proposed

the live performer

Theo

Be absolutely predictable: scene 27 launches scene 27 every single time. Destructive commands must be impossible to trigger by accident, and the palette must be legible in a dark room at arm’s length.

Proposed

the mix engineer

Priya

Expose queries as well as commands: which tracks are frozen, the routing of track 12. House templates as reusable commands, in the host’s own vocabulary, so her muscle memory transfers.

Proposed

the educator

Sam

A log that is readable on a projector and expressible as something students could type. The AI layer must explain its plan in the same vocabulary.

Proposed

the extension builder

Jonah

An SDK with a clear command schema, a local test harness and a way to hand commands to colleagues without a marketplace. He ships his first extension in an afternoon.

Proposed

The research

31 interviews, 412 respondents

The five personas were built from interviews with producers, engineers, live performers and educators between June and September 2026, and a survey of 412 DAW users. The split that shaped the product: 83 % would accept an assistant that shows a plan before acting, 11 % one that acts unseen.

Reported

31interviews

producers, engineers, live performers and educators, June to September 2026

412survey respondents

recruited from DAW user communities; Live is the primary DAW for 61 %

78 %already use a desktop launcher daily

Spotlight, Alfred, Raycast, PowerToys Run or similar

71 %named navigation as a top-three friction

repetition 58 %, recall 46 %; the risk of a mis-click, 64 % of the 97 performers

83 %would accept an assistant that shows a plan before acting

against 11 % for one that acts without showing one: the basis of the plan-preview model

57 %would build a custom command if it took under 15 minutes

23 % have written or modified a Remote Script, a controller script or a Max for Live device

Hosts

One host in 1.0. The contract is written for more.

Roadie sits beside the DAW, not inside it: it is not a plug-in and not a Max for Live device, because either would tie it to one host and one window. The adapter is the only part that knows anything about a particular DAW.

The 1.0 host

Ableton Live 11 and 12

The 1.0 host, through the open-source ableton-liveapi-tools Remote Script (GPL-3.0), shipped unmodified beside Roadie and never linked: 220 actions over a local JSON socket. Take lanes and display values need Live 12.

Proposed

A 1.x candidate

Bitwig Studio

A 1.x candidate, through a controller extension speaking the same protocol; it would be the first host with real cursor tracking and an undo depth.

Open question

A 1.x candidate

REAPER

A 1.x candidate, through ReaScript or the Web Remote; its action list is addressable by id, which makes a very large vocabulary cheap to expose.

Open question

Not planned

Logic Pro

Not planned: no public control API beyond Scripter and key commands, so an adapter would be limited to transport and keyboard-driven commands.

Open question

Extensions

A text editor is the SDK.

Three extensions ship in the SDK repository as worked examples and are installable from the first-run card.

Reference extension

Session Hygiene

Colour and name tracks by kind, remove empty scenes with a confirmation per scene, freeze heavy tracks.

Proposed

Reference extension

Performance Kit

Scene launch by number with confirmation off, group mute and unmute by colour, tempo nudge presets, follow-action timing presets.

Proposed

Reference extension

Teaching Log

Export the session log as a numbered handout with each step’s plain-language description.

Proposed

What an extension can and cannot do

  • A macro is a JSON file: a name, aliases, typed arguments and a list of steps with bindings. A non-programmer authors one in under ten minutes.
  • A scripted command is a function in an embedded JavaScript interpreter with no file system, network or process access; it receives the arguments and a read-only context and returns steps. 200 ms and 16 MB, or a typed error.
  • Steps from a script pass the same validator as an AI plan: reference grounding, scope limiting, the tier policy. An extension cannot do anything the user could not do by typing.
  • roadie-sdk checks a folder against the schema, runs a macro or a script against a recorded snapshot, and reports the plan’s tier and grounding before anything touches a host.
  • Sharing is copying a folder. No store, no signing, no review in 1.0; a signed-extension model and a community index are 1.x candidates.
How it was planned

Six milestones, as the book set them.

The release plan of RDE-SPEC-001, kept for the record: a skeleton in November 2026, a public 1.0 in April 2027. Roadie is on sale now, ahead of that plan, on the owner’s word of 24 October 2026.

M1Skeleton

Palette shell on macOS, the hotkey, grammar layers 1 and 2, a Live adapter with transport and tracks, the log

Nov 2026

M2Vocabulary

The full Live vocabulary mapped and tiered; the validator and the policy; previews; undo bookkeeping

Dec 2026

M3Assist

The AI layer with remote and local providers; context compaction; the adversarial corpus; the Windows shell

Jan 2027

M4Extend

The SDK, macros, scripted commands, roadie-sdk, the three reference extensions

Feb 2027

M5Harden

Performance mode, the accessibility pass, the performance gates, telemetry, crash reporting

Mar 2027

1.0Release

Public release on macOS and Windows, for Live 11 and 12

Apr 2027

Spec sheet

The budgets, the tiers, the catalogue, the wire.

Latency budgets

p95 unless noted. Each one is a release gate, measured on the reference hardware and reported in the release notes; a regression of more than 20 % between builds blocks a release until explained.

PathBudgetMeasured from → to
Hotkey → palette visible16 mskey-down → first frame presented
Hotkey → input accepts a keystroke80 mskey-down → character rendered
Keystroke → results updated16 mskey-down → rows rendered
Enter → tier 1 action acknowledged by the host150 mskey-down → ok response parsed
Enter → tier 2 preview shown50 mskey-down → preview rendered
Macro of 8 steps → all acknowledged400 mskey-down → last ok
> request → preview, remote provider2.5 s at p75; 6 s timeoutkey-down → preview rendered
Palette hide16 mskey-down → window hidden
Zero-state suggestions reflect a host change2 shost change → row updated

Resource budgets

ResourceBudget
Idle CPU, palette hidden, host connectedunder 0.5 % of one core
Idle memoryunder 80 MB resident
Peak memory during a full snapshot of 128 tracksunder 200 MB
Diskunder 40 MB installed, extensions aside
Network with the AI layer offzero bytes

Risk tiers

Tiers are defined on the action, not the command, so a macro inherits the highest tier of its members and an AI plan is tiered by its worst step.

TierMeaningConfirmationExamples
0Read-only queryNoneget_track_info, get_session_info
1Reversible state change with no data lossNone; loggedset_tempo, mute_track, launch_scene
2Reversible but structural, or affects many objectsPreview shown, Enter to runcreate_midi_track, add_device, quantize_clip
3Destructive, hard to reverse, or affects filesExplicit confirmation with ⌘↩, never batcheddelete_track, delete_clip, flatten_track, consolidate_clip

The built-in catalogue

Every built-in command for the Ableton Live adapter, by tier.

TierCommandsWhat the tier means
043queries: they read and never write
179run at once and are logged
242preview first, Enter to run
314confirm with ⌘↩, one at a time
Total178178 commands over 220 script actions; a command marked Live 12 is hidden on Live 11

Protocol timing

The one measured table on this page: the book’s own measurements against Live 12 on the reference hardware, through the upstream Remote Script, which processes one queued command per display tick at about 60 Hz. The adapter uses them to set its timeouts and to estimate a macro’s duration in a preview.

OperationMedianp95
ping round trip18 ms34 ms
set_tempo19 ms36 ms
get_track_info, a track with 6 devices21 ms41 ms
create_midi_track48 ms110 ms
load_device, a native device140 ms420 ms
freeze_track, an 8-bar clip with 4 devicesblocking; the script returns after Live completes1.5 to 6 s
search_browser, limit 4065 ms180 ms

Measured. The three slowest rows carry an expect-delay flag in their action specification, so a preview can say so and the executor can extend its timeout to 10 s for them.

Permissions

PlatformPermissionWhen requestedWhy
macOSInput MonitoringFirst runthe global hotkey
macOSAccessibilityOnly if focus follows host is enabledreading the focused window’s owner
macOSNetwork, outgoingOnly when a remote provider is configuredAI requests
WindowsNone beyond user level—a global hook through RegisterHotKey, no elevation

Roadie never requests Full Disk Access, Screen Recording, the microphone or the camera, and installs no kernel extension, driver or launch agent.

Out of scope for 1.0

  • Audio processing of any kind: Roadie never touches an audio buffer, only the host’s control surface.
  • Generative audio or MIDI beyond what a discrete host action can express; it can add notes to a clip because the host exposes add_notes, it does not synthesise audio.
  • A plugin host, a mixer or any surface that duplicates what the DAW already draws.
  • Cloud sync of sessions or presets: all project-specific data stays on the machine.
  • Mobile and tablet clients.
  • DAWs other than Ableton Live in the shipping build; the adapter contract is designed so Bitwig and REAPER adapters can follow without changes to the palette or the AI layer.

What is left open

  • The derived cursor on Live: the reference script does not expose the selected track, so Roadie infers it from its own last focus command and warns when it may be stale.
  • The send and volume curves: Live’s mixer curve is not published; the adapter’s dB table is empirical and is to be validated across the full range before 1.0.
  • The default AI provider: shipping with it off is safest and least useful; which vendor to recommend is a product decision not yet made.
  • The tier of capture_midi: it creates content and is undoable, and sits at tier 3 because an accidental capture on stage is disruptive.
  • The performance-mode ! suffix, the Windows hotkey under a controller’s focus, and two protocol changes proposed upstream: request ids and an authenticated handshake.

The reference script binds 127.0.0.1:9004 with no authentication, and any local process can send it commands. Roadie cannot fix that in 1.0 because the script is an upstream project; the first-run card and the install command say so before copying it, and a shared-secret handshake has been proposed upstream.

Roadie is on sale.ReportedOn the owner’s word of 24 October 2026. RDE-SPEC-001 v1.0, released on 16 October 2026 as a draft for review with every approval pending, is still the specification: its plan ran from M1 Skeleton in November 2026 to a public 1.0 in April 2027, on macOS and Windows, for Live 11 and 12. The protocol timings are the only measured rows on this page: the book took them against Live 12 on the reference hardware through the upstream Remote Script. The interview and survey figures are its research synthesis. Its price is on the pricing page; the book names none.

Every figure on this page is from “Roadie — Product & Technical Specification”, v1.0, 16 October 2026 (RDE-SPEC-001, a draft for review), and carries this site’s tag: Proposed for a 1.0 target, Measured for the protocol timings the book took against Live 12, Reported for its research. Its price is the owner’s, set on 24 October 2026, and the book names none.