The Engineer

The composer

At the bottom of the panel:

• The prompt line — a › mark and your text in phosphor. Type anything: questions, one-off moves, edits, or full mix briefs. It grows to a few lines as you type.
• The status line under it, every control a word. Each word lights and takes a pointing cursor where it can be clicked, and clicking one never takes the keyboard away from the prompt:
  • AUTO MIX — the one-button bootstrap (next chapter).
  • REFERENCE — opens the Reference card (see Analysis & References). When the panel is narrow this word hides; the reference is still one click away under + attach.
  • OPUS 5 — the model word: the Claude model the engineer runs on. Click it for every current model, grouped by family. It is the first word to give way when the panel is narrow; the effort menu's Model: submenu still reaches it.
  • HIGH — the reasoning-effort ladder (Low / Medium / High / X-High / Max). Click it and each row in the menu says what that level is for; the menu lists only the levels the picked model has, and the word shows the level the model actually gets. Your picks ride every message you send, so they hold from the first message after a relaunch, and each open project keeps its own.
  • ASK | AGENT — the mode toggle (below); the live mode is lit with an underline.
  • ↑ — send. While the engineer works, the feed's working line carries STOP.
  • The dot at the left is the engineer's presence — it breathes amber while it works.

Context riding with your message: tokens above the prompt show the selected track (its name in the track's own colour) and the loaded reference; a time selection in the arrangement auto-attaches as a selection token (dismissable). The + attach control adds explicit tokens — Track, a Device on the selected track, the Selection, the Reference — and @name mentions a track mid-sentence with type-ahead. "Make this part darker" just works: the engineer reads your selection.

Ask vs Agent

• Agent (the default working mode) — the engineer applies what you asked for directly: shared control, no approval popups, everything undoable. One request = one undo step, no matter how many moves it took.
• Ask — nothing is touched. The engineer plans: mutating actions are recorded as a step list and rendered as a jade preview ledger. Saying "do it" (or pressing the ledger's button) applies exactly the recorded steps — what you approved is what runs, not a fresh interpretation. Each preview's do it applies that preview's own steps, once, and goes dim when it has run. A preview stays a proposal when you reopen the conversation. Answering one of the engineer's questions, or clicking an observation's verb, follows the mode you are in, so in Ask those preview too. Ask is also the mode for advice ("what would you do about this low end?").

The feed

The transcript reads like a terminal:

• Every change is a sentence: tightened vocals compressor 2.4:1 → 3.2:1, with the track named in its own colour and the new value in phosphor — and under it, dimmed, why the engineer did it (holds the chorus lines steady). Moves that belong to one decision share one why-line. Click a sentence to jump to that track's device.
• Tool rows show was → now: set bass gain / +0.0 → −3.0 dB. The after-value is re-read from the live engine, so a refused or clamped move shows what actually happened. Rows with more behind them say DETAILS; click to open the arguments. A call that failed says FAILED in that same place and arrives already open on its reason.
• While it works, one amber line (LISTENING ▮ …, then the pass count, the time elapsed, the spend so far and STOP), and the moves land above it as they happen. STOP cancels the run. Questions you ask mid-run count toward the session total too.
• The only amber in the feed is that working line; the only marks are the › of your own lines.
• Real streaming — replies stream token-by-token, with light markdown (bold, code, bullets, headings). Scrolling up to read is never yanked back down; the view follows the tail only when you're already at the bottom.
• The conversation stays whole — a session's transcript scrolls; nothing collapses on its own. To tidy one exchange away, click its own line and it folds to a summary row (› brief · 3 moves · → −14.5); click again to re-open. The line lights under the pointer whether it is open or folded, and the target is the brief itself — both lines of a two-line one. Reopening a session brings the whole conversation back, scrolled to where you left it.
• Your own lines sit under a ›, the terminal's prompt mark.
• Per exchange, the feed offers undo run (revert the whole gesture, while it is still the newest one), a/b (press and hold to hear the device chains as they were when you sent the request; release puts back exactly what is live, your later tweaks included), and jump (select the track and open its device pane).
• Questions with one-click answers — when a request is genuinely ambiguous ("which vocal clip?"), the engineer asks with two to four options drawn as links; click one and it is sent as your next message, in the mode you are in (in Ask it previews). It is told never to ask what the project already answers.
• A plan card — for anything that takes more than a couple of moves it sets out the steps first, in your words, and updates the same card as each lands: done steps dim, the current one is amber. An unfinished plan is still in its context next turn.
• A measured line under each move — when the engineer moves a fader or a device, one phosphor line lands right under that row saying what the master actually did (TP 2.0 · LUFS −12.2 → TP −0.3 · LUFS −12.4), measured, not predicted, and it reads the number before its next move. A turn's overall change lands after the reply.
• "A or B?" — after a move you might not agree with, the engineer can offer a two-option card: A — before, put it back / B — after, keep it. Hold a/b above it to hear both, then click. Your choice is remembered as taste (B is the strongest "yes" it can learn; A undoes the move), and it says so.

Sessions

Conversations are sessions — each with its own title, transcript, and the agent's own memory of it. They live in the rail down the left of the panel: every conversation in this project, grouped today / yesterday / earlier, newest first, the open one lit. Under each title is what it is worth knowing before you re-open it — how long ago, how many turns, and what it has cost. Conversations from the project's other edits are listed too, under that edit's name; opening one switches to that edit first (its tooltip says so).

Click a row to switch, right-click one to rename or delete, and + new starts a conversation with an empty context (a clean, cheap slate — context is what a turn is billed for). The search line above the list matches both a session's name and the words said in it; a match found in the conversation shows the line it found under the title. Open that result and it takes you to the words — the session opens scrolled to the first match, with every matching line marked down its left edge.

Clearing the search clears the marks. Clicking the session you are already in searches the conversation you are reading.

Fold the rail with the ‹ in its header (or ⌥⌘S, or View ▸ Session Rail) and it becomes a narrow spine — the count, the open session's bar, and + — handing the width back to the arrangement. ⌥⌘E hides the Engineer panel altogether. Both are remembered between launches, and the agent can work them too ("fold away the sessions, I need the room").

Sessions are stored per edit inside the project and reload on open — the engineer remembers what was said last week in that session. The engineer can also see the list: it knows which conversations this project holds, how long ago each was used and how much was said in it, so you can ask about one by name. Titles come from your first message (rename anytime). Switching rolls nothing back: undo is still per run.

While the engineer is answering, the session it is answering in wears an amber point and the other rows dim: a switch mid-turn is refused, so the rail says so before you click. A session change (or a new session) lands after the turn, or after Stop.

A fresh session opens on the console, not a blank page: the tracks named in their colours with the song's key · BPM, then observations — real findings from analysis ("the pads are crowding the vocal between 2–4 kHz — untangle it") whose trailing verb is a click-to-run action. (Loudness, peak and width live in the transport and the meters, not here.)

While it works

• The ENGINEER cell breathes amber and names the phase; runs show pass N/M and a live $ spend readout.
• ■ Stop cancels at the next safe boundary. Whatever had already landed stays (one Undo away), and the feed says exactly what was kept.
• A request that fails part-way (a lost connection, a usage limit) says what had already applied and offers no retry, because asking again would do those steps a second time. The engineer also remembers what ran, so your next message won't repeat it. A usage limit says so in the words Claude gave (with its reset time); an expired sign-in token names the fix. If the engineer itself stops mid-turn, there is no retry either: when it comes back, the feed lists the moves that had already landed (⌥⌘Z takes them back).
• Every tool row settles honestly. A move the guardrails refused ends as FAILED with the reason under it, not as a finished "read".
• Chatting mid-run is fine: your message appears once, just above the working line, is answered from current state right away (it can't change the project mid-run), and the next real turn picks it up first, clearly marked as having arrived during the run.
• Question cards answer with one click once the engineer has finished its turn (a click while it is still working says so and leaves the card live). A card you left unanswered goes dead as soon as you send something else.

Taste, memory, and honesty

• It learns your taste silently: an agent move you undo — with ⌥⌘Z, or by telling it "no, put that back" — is a strong "no"; a move still standing when your next request has finished is a weak "yes". An A/B answer counts once, as your explicit choice. All of it feeds how it mixes for you. (Automatic rollbacks don't count against you.)
• save_note — tell it "remember I like the vocal dry" and it saves a durable note to the project, loaded every session.
• It volunteers findings — the worst masking pair, the most detuned stem, spitty sibilance, a master resonance — in its own words, with the why, not just the what.
• Every move carries its reasoning: the ledger keeps each move's rationale and predicted effect; get_proposals (ask "show me what you predicted vs measured") returns the full history.
• It remembers where you left off: every turn is digested to the project (runs/session_digest.jsonl); on the next launch the engineer opens with the last few exchanges of earlier sessions — what you asked, what it invoked, whether it had an open question — so "carry on with the vocal" means something.
• It can look at one part: point it at a time range ("the second chorus", the selection, "the end of the clip") and it reads that region of a stem — loudness and its envelope, dynamics, spectrum and whether it brightens or dulls across the region, transients, and which other stems mask it there — before deciding a ranged move.

Watching it work

Anything the agent touches glows amber — the fader, the device box, the clip, the track header, the transport cell — holding briefly and fading. The ✦ agent button on a track's header/strip lights while the engineer is working that specific track. Nothing the agent does is invisible.

What it can and cannot touch

The engineer operates the entire DAW through the same commands as your clicks — tracks, clips, devices, mixer, routing, automation, tempo, markers, MIDI composition, recording, the Loop Deck, the library, even preferences-level things like meter styles. The deliberate exceptions:

• Your loop and your viewport are yours — 30 view/navigation commands (the loop brace, zoom and follow, playhead nudges, track folding and height, the selection keys, the Loop Deck's loop-length keys, draw mode, the palette, the shortcut editor) are refused on the agent path.
• 16 commands need your explicit yes — the ones no undo can take back: deleting an edit or library item, opening/switching projects, importing a track, chain, or DAWproject from another project, trusting or quarantining a plug-in, exporting with settings, writing a groove file, re-pointing MIDI sync / control surfaces / OSC, re-pairing your audio inputs, changing a MIDI input's settings. Two more ask per call: moving the master's main out to another hardware device, and saving a rack preset over one that already has that name. A real dialog appears; unattended sessions auto-refuse. While the dialog is up the engineer waits for you; if it gives up anyway, the dialog closes and nothing runs.
• Its direct level commands are bounded to −60…+12 dB, the same range the project file keeps (out-of-range values are refused, so it sees its own mistake). The same goes for every other number it types — pan is −1…1, tempo 20…300 BPM, a plug-in parameter 0…1 — and a value that isn't a number at all is refused rather than guessed. It cannot switch off or bypass the master safety limiter — only you can (⌥⌘L). During a mix run it must propose level and device moves rather than set them directly, and its mix-run passes are guardrailed server-side — gain moves ≤ ±6 dB per pass, EQ boosts ≤ +6 dB, master true peak ≤ −1 dBTP, at most 24 actions per pass.

Undo and the agent

There are two undo stacks, and they cover different things.

• ⌘Z is the timeline's undo, shared with your own edits. It takes back what the agent did with DAW commands (clips, tracks, faders, devices it set), one whole agent turn per press — however many commands the turn ran and however long it took between them — and ⇧⌘Z brings the whole turn back. An edit of your own made while the agent was working is yours: the press stops there, and the next one takes the rest of the turn. It does not reach the agent's mix moves: the EQ, compression and master-chain changes a run or a chat turn applies through its ledger. ⌘Z after one of those undoes whatever timeline edit came before it instead, and the status line says so: Undid ‹that edit›. The engineer's later mix move is still in — ⌥⌘Z.
• The engineer asks before it removes an FX return or dissolves a group: neither undo can bring one back with its devices and sends, so a box names the return or group and nothing is removed until you press Do it. (Removing one yourself is not asked about.)
• ⌥⌘Z (undo agent move) and the feed's undo run take back the agent's mix moves through the brain's own ledger, one whole gesture per press, together with that gesture's timeline edits. The knob and fader moves you made since are kept. If you already took the timeline half back with ⌘Z (or edited since), ⌥⌘Z reverts the mix moves, leaves the timeline alone, and says so.
• undo run takes back only the exchange it sits under, and only while that exchange is the newest agent gesture. Under an older exchange it says so and does nothing; use ⌥⌘Z to step back one gesture at a time. A conversation reopened from the sessions rail keeps its jump verbs but not undo run.
• A request that fails partway keeps what already landed as one gesture: the error says how many moves applied, and one ⌥⌘Z takes them back.

When the engineer can't run

Nothing else breaks. With no Anthropic key yet or no account linked, one sentence at the foot of the console says why — the composer keeps your message instead of sending it — and clicking the sentence takes you to the remedy (see Account and Updates). Recording, editing, devices, plug-ins, and export never depend on the engineer.