Arrange — write and arrange with the agent

The Arrange workspace is Studio's agentic-DAW view. The arrangement is drawn in the colours of the song's patterns, which are listed down the left; the focused pattern's editor sits under it, and the agent on the right writes into what you focused. Every change is ordinary Volta source: compiled before it lands, one Undo step, and visible in Source.

Open it#

The first chip of the header's navigation strip names the workspace you are in (LAYOUT CLASSIC ▾ before you pick one; just the name below 1440 pt of window width). Click it and pick Arrange. The same menu offers Code, Mix, Perform, Produce, your saved layouts, Classic (the custom workspace off) and Rearrange panes; Display ▸ Workspace keeps the full settings. The window divides into:

• Pool on the left: the song's patterns.
• Timeline in the middle, opened on the song map, with Pattern (the focused pattern's editor), Rack and Mixer as tabs below it.
• Agent on the right: the copilot as a pane, with History (the song's journal: who changed what, heard and put back, Save ideas, compare versions and record takes) as a tab beside it.

Arrange opens on the song's first pattern, so the editor is never empty while the song has one. Produce docks the same Pool, pattern colours and Pattern pane beside its Patterns sheet and Mixer, without the Agent (Make a song by writing only patterns § Patterns in focus).

A Timeline docked in a workspace folds its toolbar into one row: view tabs, zoom, Harmony, ? (help), Follow, Snap, the pass selector (◀ n ▶ LIVE), on a scene song a FORM ▾ menu (the form's length, HOLD FORM and COPY FORM), and in Arrange the COLOUR toggle. The song's name, tempo and meter are not repeated over the map, because the header shows them. The row wraps only when the pane is too narrow for it.

Any pane moves, resizes or hides as in Workspace layouts. In a workspace that docks the Agent pane, the COPILOT button brings that pane forward instead of opening the copilot column (which would leave the workspace); HISTORY likewise brings the History tab forward. The Patterns sheet is not in Arrange; Rearrange panes adds it back, and docked beside the Pool it joins the focus as it does in Produce.

What a pattern is here#

A pattern is what a Timeline clip's label already says: the named pattern a clip plays (riff, even when the track plays riff |> fast 2), the binding that declares an arrange list of unnamed parts (bassPart), or, for a track that writes its pattern inline (kit = sound !"bd sn"), the track itself. Two tracks that play one pattern share it. Each pattern has a colour, given in the order the patterns are written (a track's own at its track), so moving or dropping a clip never repaints another. While the song stays open a pattern keeps its colour across edits, so a pattern written mid-list (Duplicate as new pattern) takes a free colour instead of shifting the later ones (Pool::keep_slots); reopened, colours follow declaration order again.

The Pool#

The Pool lists the song's patterns as cards, in colour order. A card shows the pattern's colour and name, where it plays (plays on subTrack, bassTrack · ×5, or not placed), a thumbnail, and a strip of the whole song with this pattern's placements lit.

The thumbnail draws the pattern the way the Rack case's sequencer does: steps for a drum line, a small roll for a pitched line (its range spelled as the source writes it: Bb1 – G2, not A#1), a wheel for a pattern whose period runs against the bar. While the song plays, it carries a playhead and lights the notes sounding under it (on a written timeline too).

• Click a card to focus its pattern: the Timeline lights its placements and the Pattern pane opens it. ↑ / ↓ move the focus while the Pool has the keyboard.
• Drag a card onto a track's row in the Timeline to place it there: a region of that pattern at the bar under the pointer, the same checked edit as the Patterns sheet's idea drag. Dragging is offered on a written timeline only; elsewhere the card's hover says why.
• 🔊 plays the pattern alone on the first track that plays it, rendered offline, without moving the song. Click it again to stop.
• + pattern adds a named pattern for you to type over and focuses it.
• ⋯ offers Duplicate as new pattern (a copy, riff2, written on the line after the original and played by no track yet), Rename (everywhere the compiler resolves the name) and, for a named pattern nothing plays, Remove. A track's own pattern (written inside the track, bass = play v !"a1 c2") offers Name it instead: the pattern moves into its own binding on the line above (bassPat = !"a1 c2"), the track plays it by name, and the new pattern is focused — after which it can be duplicated, placed and renamed like any other.

Each write is checked by the compiler first and is one Undo step; the song follows its Undo and Redo.

The arrangement in pattern colours#

In Arrange, each clip on the song map wears its pattern's colour instead of its track's: the same pattern on two tracks looks the same, and a section that repeats reads as a repeat. Track headers keep the track's colour. The focused pattern's clips get an outline in its colour; every other clip fades back, so where the pattern plays is one look. The clip's hover names the pattern and how many placements it has (pattern wireIdea · 8 placements).

COLOUR · PATTERN in the toolbar switches back to track colours (COLOUR · TRACK; the focus outline stays). The choice is remembered. Outside a workspace that docks the Pool, the song map keeps track colours.

Clicking a clip selects it, as before, and focuses its pattern. Focusing a pattern from the Pool scrolls the Timeline once so its first clip is on screen when its track is above or below the visible rows.

The Pattern pane#

The Pattern pane edits the focused pattern, and wears the colour the Timeline paints its clip — the swatch, the placement strip, the steps, the roll's notes and the text line's lights. Under COLOUR · TRACK it wears the focused track's colour instead. Its header shows the pattern's colour, name and where it plays; the transforms between the written pattern and the focused clip, as chips (fast 2, every 4 rev); and a strip of the song with one lane per track that plays it. Click a placement to focus that occurrence: its bars, and the region selected on the Timeline. On a scene song a placement opens as a click on its Timeline clip does: the other tracks of that pass behind the roll, and make variation for this occurrence.

STEPS and ROLL switch the editor. A drum pattern opens in Steps, a pitched line in Roll; the choice is remembered for each pattern while Studio is open.

Steps draws the pattern itself as a step grid, not the track that plays it (read on a background thread: the first time a pattern opens it says Reading the steps… for a moment): a row per sound (a sample, or a pitch), sixteen steps a cycle (24 or 32 when the notes need a finer grid), and a page per cycle of a pattern that alternates (<…>), with FOLLOW to show the playing cycle. The playing step lights while the song plays. Click a step to add or remove a hit: the cell changes at once, then the pattern is rewritten, compiled, and kept only if it then plays exactly the hits the grid shows, as one Undo step — several quick clicks land in order, one Undo step each. If the pattern was rewritten some other way in the meantime, the click is refused with a note and the cells go back. A note held across steps is drawn as one bar from its hit. A pattern several tracks play says changes kitA and kitB, because the edit changes them all. A pattern the grid cannot write back (notes between steps, per-note controls, numbers, a note held across the cycle line) is drawn read-only, with the reason, and Roll and the text line still edit it.

Roll is the Bench's piano roll, as before:

• A note click is one Undo step; a drag is one Undo step however many frames it lasts.
• The other tracks sounding in those bars are drawn faintly behind the notes, the velocity strip writes =N on a note, and Written / Result switch between the notes as written and as the track plays them. A clip on a written timeline opens Result on the region's own notes, at the first cycle that has some.
• When the clip's pattern is placed more than once the roll says how many placements an edit changes, and offers make variation for this occurrence (Write a song as a timeline § Make a variation).
• Its controls ride the pane's header row and the notes fill the rest of the pane. A pattern that is computed rather than written as notes (arrange [[1, !"a1"], …]) is shown as what it plays, marked READ-ONLY; change it in the text line or in Source.

Duplicate, Humanize and Quantize work in both views. Humanize adds |> humanize 0.05 to the pattern (again: +0.05, up to 1). Quantize removes it: the notes of a written pattern are already on the grid, so Quantize never moves a note. Duplicate doubles the pattern's length (<[p] [p]>). Each is checked by the compiler first and is one Undo step.

The text line at the foot of the pane is the pattern as text, the same field as the Patterns sheet's row (Make a song by writing only patterns): Enter writes and runs it, Escape puts it back, a draft is compiled when you pause and the compiler's sentence shows under it in the alert colour, and the playing steps light up while the song plays. A pattern written over several lines scrolls inside three rows, so the editor above keeps the pane.

Edit notes (a track page, a Patterns row's ♪, a region double-click) opens the Pattern pane too. Outside a workspace with a Pattern pane, Edit notes opens the Bench as before. Scene songs (song { scenes, arrange }) work the same way: click a clip and it is outlined as the selection (one track in one arrange cell) and its pattern opens here. With a Source pane on screen, a click still reveals the clip's source.

The Agent pane#

With a region selected, the agent reads it: the panel says selection: lead · bars 9–12 · plays leadIdea (2 placements), and every request carries that track, its bars, section and pattern, and the other tracks' notes in those bars. Choose write and describe the part — "a counter-melody over the chorus chords". The agent writes it as a new pattern (leadPart) and only the selected region is pointed at it, so the other placements of a shared phrase never change.

With nothing selected on the Timeline, the agent's subject is the focused pattern where it plays: the placement the Pattern pane shows, else its first one. Arrange opens focused, so write has a target before any click. A pattern nothing places, or a loop with no form, leaves no selection; then write asks you to select a clip and sends nothing.

In a scene song the selection is the clicked clip's section (selection: bassTrack · bars 17–24 · plays bassIdea (2 placements) — placements count the sections the pattern plays in). When the pattern plays in that section only, write rewrites it in place. When it is shared, the agent writes a new pattern (bassIdea2) and the workbench gives only that section its own part, the same edit as make variation for this occurrence: a copy of the track playing the new pattern and the section's own scene (drop2) in that one arrange cell. Every other section keeps what it played. The selection then follows the new track (bassTrack2), so the next ask is about the part that plays there now, and the receipt's open in Pattern opens it.

Its steps appear as rows above the reply (thinking, each tool it called, the workbench's compile of the draft). After verify & apply, a receipt says what changed, counted from the compiled song before and after — e.g. Added 16 notes to lead, removed 16 · bars 9–12 — with open in Pattern, undo and dismiss. Undo takes the apply back at any later time: the editor's own undo while the buffer has not moved since, else a revert of the version the write minted (only its parts go back; later edits stay). The trace ends with Applied v12 — open in History, a link that selects that version in History (Save ideas, compare versions and record takes). The rest of the copilot is unchanged: Create with Copilot.

Look#

The pane reads top to bottom like a conversation with an instrument, the same in the docked Agent pane and the copilot column (ui/src/agentpane.rs paints it; ui/src/aiview.rs arranges it):

• The mark. A ring around a core in the theme's agent hue (the colour of work someone else put in your buffer). At rest it is still; while the agent works the core breathes and a wave leaves the ring (wall clock, only while a run is live; Reduce motion keeps the colour and drops the movement). Beside it, the status — ready, thinking…, writing…, turn 2/6 · 1.2k tokens · measuring… — and, quiet on the right, the provider, the model, who it is teaching and clear.
• The conversation. Your request is a card leaning right; a reply opens with a small mark and its author, then the reply document. A turn that only called tools draws nothing of its own. The run's steps sit between your request and the reply as a rail: a hairline joining one node per step — hollow for a thought, filled when a call came back, lit in the agent hue while it runs, alert-red when it failed — with the step, its argument in the code face and its outcome on the right; the header folds it. A clean compile is that rail row alone; a tool result with something to open (an IR dump, a measurement, a skin verdict, errors) keeps its card.
• Edits. The proposed edit is a card with the agent's stripe down its edge. After verify & apply the receipt closes the conversation as a clip: per changed track its lane colour, name, bars and +added −removed, over a strip of the song with the changed bars lit; then open in Pattern, undo, dismiss. It glows once as it lands. The applied write's row on the rail is a link in the agent hue to the version it minted.
• The composer, docked at the bottom: the mode rail, the selection as a pill in the track's colour (lead · bars 9–12 · leadIdea ×2; a dashed pill in write when nothing is selected), the field, and the send bar (the mode's toggles left, send right, stop while a run is live).
• Empty. A new conversation shows the mark, What should we make? (or Write into lead · bars 9–12 with a selection) and four example asks; a click fills the field and picks the mode. With a selection the asks are about it.

Light is the luminous family's only (light::chrome): under the working mark and the running step, the receipt's arrival, the proposed edit and the focused composer. Every other skin paints the same layout with solid fills and hairlines. VOLTA_LOOK_DIR=<dir> cargo test -p volta-ui --profile fast --test suite agent_look:: -- --ignored renders every state under two skins at three pane widths (ui/tests/agent_look.rs).

Arrange verbs#

Ask in edit, continue or write for an arrangement change — "loop the drum pattern through eight bars", "copy the chorus lead to bar 17", "rename t1 to drums" — and the agent answers with typed operations the workbench applies, not a rewritten region list:

The agent sees the regions it can address: every request in those modes carries an Arrangement block listing each track's region ids, their bars, what they play and their pass length. Bars are counted from 1. The ops run in order, after the reply's volta-edit / volta-add fences, each against the compiled song the previous one left, so one reply can add a part and loop it.

The result is an ordinary candidate: verify & apply compiles it, the whole reply is one Undo step, and the receipt has a line per op ahead of the note counts — Looped t1 · bars 1–8, then Added 18 notes to t1 · bars 3–8.

An op the workbench cannot apply refuses the whole reply, with one line under it (arrange op refused — loop drums:0: no region drums:0 in this song…), and nothing is applied:

• a region id the song does not have;
• one pass of a repeat or group (its written region plays every pass);
• a region placed in seconds, or one that plays once (repeat = "once") asked to grow;
• a song without a written timeline (only rename_track applies there).

Track colour is not an op: a track's colour comes from the workbench, not from the source.

Limits#

• An empty stretch of a track cannot be selected yet.
• A Pool card drags onto a written timeline only; a scene song places patterns through its scenes, edited on the Timeline.
• A transform written over an arrange list of parts (bassPart |> fast 2) shows no chip.
• A step click lights its cell at once and is proved on a background thread; landing it still re-checks the song on the interface thread (15–20 ms measured headless on a large song).
• The arrange ops cover regions on a written timeline and track names; sections, markers and repeat counts are still edited on the Timeline.
• The browser workbench has not been rebuilt with this workspace.