The final episode, the one this series has been saving. HELIX has an assistant living inside it: you talk to it, typed or spoken, and it runs the physics, reads the plots, drives the interface, and answers from the manual. This voice, which has narrated every episode, is the assistant's own. Today you watch it work exhaustively, every control and every tier of its safety model on camera, recorded live while this video was being made.
Open it from the toolbar and the assistant appears in its own window beside the workbench. Top to bottom: the orb and its lamp, which name the assistant's state; a status row; the backend row, where you choose the brain; the conversation view; four quick action chips; the input row; and the options row. We pressed A plus twice so the text reads on camera.
Up close. The status row: the backend button, which reopens the provider row after you connect, and a small latency readout. The provider row: backend selector, password masked key field, editable model box, Connect. The chips: guided tour, training drill, Python sandbox, capability list. The input row: Hold, for push to talk; the HELIX toggle, for hands free wake word listening; the input line, Send, and Stop. The options: auto approve compute for this session, speak replies, instant commands, narrate events, watch runs, and Text, which hides the transcript for a voice only view, plus A minus and A plus for the text size.
The orb is the assistant's face, and this is its full vocabulary, on the real widget. Idle, cyan. Listening, blue, microphone open. Thinking, amber, while a model reasons or a tool runs. Responding, bright cyan, with an equaliser ring, a synthesised voice print, while it speaks. Awaiting confirm, pink: waiting for your approval and nothing else. Error, red. Off, grey, when hands free listening is disabled. The colour morphs rather than snaps.
Before connecting, the three backends. Anthropic by A P I key: the key goes in this masked field, is stored in the application settings on this machine, and never appears in a ledger. Local, or OpenAI compatible: one box takes the server U R L, or U R L and model together. And Claude by subscription login, no key at all, through the Claude agent S D K, with the aliases fable, opus, sonnet and haiku; blank means the default. Connect. The status line pins the provider and the ledger file name, the provider row folds away, and on a first connection a hello card maps what the assistant can do. Then a real question: what lattice is loaded. The orb turns amber, and the reply is the model's live answer, correct because HELIX grounds it in the live application state: the deck, the element count, the results. The workbench, not the model's imagination.
The question mark chip asks the assistant what it can do. A chip simply types a real request and sends it through the normal path, so the answer arriving is the model's own live summary from this recording, not a canned list. Read it as the table of contents for the rest of this episode.
Not every request deserves a model. We type, status. The answer lands in milliseconds and the transcript says why: instant, get status. Lattice fodo cell, 22 elements, 1.6 metres, results loaded. A small set of unambiguous read only phrasings match the whole utterance exactly and run the tool directly, deterministically. Precision over recall: a missed shortcut costs one model turn, a wrong one would hijack your question, so only exact phrasings and only read tier tools qualify. Then, summarise the beam, and the honesty story: the beam summary tool refuses, because an envelope run carries no particle distribution, so the request falls through to the model, which pulls the scalar summary instead, reports exit sigmas of about two point six eight millimetres at one M e V, and says which substitution it made. Finally, list plots: the catalogue of result windows, a dozen names at a time. The Instant commands checkbox turns the whole fast path off.
Responsiveness as a number. The latency readout in the status row, cropped twice from this recording. After a model turn it shows the time to the first token, three and a half seconds here. After an instant command, the milliseconds the tool took: four. Smoothness measured, not felt.
The assistant drives the interface you already know. Show the beam tab: instant, and the workbench follows. Show the R M S plot: instant again. The Results tab comes forward and the R M S window opens as its own floating window; we untick its aperture overlay so the millimetre scale envelope fills the axes. Nested views need a model turn: open the Lattice tab's Breakdown view, and the sub tab switches. And pointing: highlight the second quadrupole. The assistant resolves the name, selects the element in the Lattice tab, and moves the s cursor to its entrance. Highlight, set cursor and get G U I context are the pointing tools: read tier, wired through thread safe queued signals, never touching the physics core.
And now the most important thirty seconds of this episode: the safety model, on camera. On the left, the Lattice tab, first quadrupole selected, gradient five tesla per metre. We ask for nine. That is a mutation, and the assistant does not touch the machine. It proposes the call, the orb turns pink, awaiting confirm, and the gate appears: Confirm mutate, then the exact resolved call, tool, element, parameter and value, one per line. Only two buttons, Approve and Deny; there is no session pass for mutations. Nothing happens until a human clicks Approve. We approve, the tool runs, the reply confirms it, and then the extra honesty: it warns that the results on screen are now stale, and offers to rerun the envelope.
The same gate, the other button. We ask for the gradient to go back to five; the call is proposed, the gate appears, and we click Deny. The gradient stays at nine, checked in the lattice object after this recording, and the denial goes back to the model as an answer like any other, so it responds rather than guesses. A gate is never left hanging, either: an unanswered confirmation auto denies after a hundred and twenty seconds.
The compute tier. We take the assistant up on its offer: rerun the envelope in the G U I. Run in G U I presses the same Run button you would, with your Numerics settings, results into the same tabs. A computation asks once, and this gate has grown a third button: Approve for the session. We click plain Approve. The run starts, the Results tab refreshes, and the exit tiles tell the story of a nine tesla per metre quadrupole in a five tesla per metre cell: sigma x from two point six seven five to four point seven one five millimetres, sigma y to five point five nine one. The loop the assistant opened, the assistant closed.
Session memory as physics tooling. Diagnose runs an ordered differential over the results, and its last check is the session ledger: it knows we changed this quadrupole minutes ago, and says so. Then we dictate a note. Notebook note appends it to a markdown lab notebook that survives across sessions; the most recent entries are folded into the assistant's context at every start up. And asking for the latest entry reads it straight back.
The Python chip. The assistant proposes real analysis code, and because run Python is compute tier, the gate appears with the code echoed for you to read. This time we click Approve for the session. Watch the auto approve checkbox along the bottom tick itself. The code runs in an isolated subprocess: an empty import path, the simulator itself hard blocked, no network, and a wall clock cap. It sees only the result columns it explicitly asked for: s, sigma x and sigma y. Its first two attempts trip over the sandbox's own conventions, and it fixes them itself; because compute is now approved for the session, the retries run with no further gate. Then the figure it saved comes back into the conversation as an image the assistant can see, and it reads the split between the two planes off its own plot.
Session approval, proven. We ask for gradient sensitivities, a compute tool, and no gate appears: the call runs straight away, ledgered as approved for the session. And then the tool refuses. This deck carries a frequency card the differentiable matrix path cannot represent, so rather than return silently wrong derivatives it declines, names the reason, and names parameter scan as the fallback. Compute runs free now; mutations still always ask.
Sight. We ask whether the beam looks matched, and the assistant looks at the R M S plot itself: it opens the window, captures the rendered figure, and analyses the image. The capture is saved under assist captures and its thumbnail lands in the transcript. The verdict is its own, from the pixels: not matched. Sigma x pinches to about one millimetre mid cell and flares to nearly five at the exit while sigma y drifts up to roughly six; asymmetric and growing rather than periodic.
The manual is indexed locally. Ask about barge in, and search manual returns the sections it matched, and the answer cites the section titles it used, the G U I section and the voice section, with no network involved. Then we ask it to search the web. Refused: HELIX is offline by default, web search is disabled unless you enable it explicitly, and the assistant relays that refusal rather than quietly reaching out.
The Tour chip starts a guided tour: fifteen stations over the real tabs, each with pre written narration and, at many stops, a hands on exercise. Station one is the welcome. Now watch the station counter: next is an instant command, but only while a tour is active, so it can never hijack a normal question. Station two switches the workbench to the Lattice tab beside; next again, station three with its Try it exercise; stop the tour ends it. And watch the lamp between stations: the follow up microphone opens for ten seconds after each one, so by voice you just keep saying next.
The Drill chip starts a training drill: a hidden fault injected into the loaded lattice, and the truth stays outside the assistant's context until the debrief, so it can relay hints without being able to spoil the answer. Injecting the fault is a mutation, so even the trainer asks first. Approve. We ask for a hint, and the first rung of the ladder names the element family; two more rungs exist, which third of the line, then the class and rough position, each costing eight points of the economy score. We give up, and the debrief reveals the truth: quadrupole four, its gradient drifted from minus five to about minus four point three eight tesla per metre. The score, thirty nine point seven, combines diagnosis, speed and hint economy, and the lattice is restored bit for bit, checked against a snapshot of every quadrupole taken before the drill.
The interrupt story. We ask for a long reply and, while it streams, send a second message. It is queued, not dropped: a small first in, first out inbox of three, and even an overflow is announced, never silent. Then Stop, or the Escape key. Streaming halts, speech is cut, a pending confirmation would be denied, and on this backend the server side generation itself is interrupted. Stop also drops the queue, and says so. The session stays usable: status answers instantly.
The options row in close up, after the session approval. Watch runs inspects every finished run, including ones you start yourself, with pure local numpy: transmission drops localised in s, sigma blow ups, emittance growth of two times or more, drift from a stored baseline; no tokens are spent until something fires. Alerts arrive as event lines, and with Narrate events on, an alert during idle gives the assistant an unprompted turn to speak up. Instant commands, Watch runs, Text and the text size persist across sessions; auto approve is deliberately per session.
Untick Text for a voice only view: the transcript hides, the orb becomes the whole face, and the conversation keeps recording underneath; tick it again and the history is intact. The window's close button hides the panel rather than killing it, and with the panel out of the way the Lattice inspector is uncovered, reading nine for the quadrupole we edited. The assistant is an application level service: it keeps running, hands free listening included, and reopening it from the toolbar, or saying HELIX, brings the same conversation back. And the backend button reopens the provider row, so you can switch brains mid session.
Everything you watched was typed, but the panel is built for speech, and these are the real controls. Hold the microphone button, or hold Space with the input line unfocused, and talk; or toggle HELIX and just say the wake word, which must address the assistant: a mention mid sentence does not trigger it. A voice activity detector gates the microphone, Whisper turns speech to text on your machine, and the reply is synthesised locally with kokoro, this voice. Talk over it and it stops and listens; after it answers, a ten second follow up window listens without the wake word. Confirmations can be spoken too, matched locally, never by the model: yes or confirm, no or cancel, no outranks yes, anything unclear is asked again, so a misheard word can never approve an action. Spoken numbers are coarsened while the exact digits stay on screen. Nothing audio ever leaves the computer.
Everything you just watched also left a record. This is the actual ledger of this recording session, selected rows: every tool call, its tier, who approved it, and its verdict. Fast path for the instant commands, user for the gates you saw clicked, denied where we clicked Deny, auto for read tools the model called on its own, and auto session once compute was approved for the session. Results the assistant writes carry assist attributes in their H D F 5 provenance, tracing every number back to its ledger entry.
A ledger can be replayed later without the model: no provider, no network, just the approved compute and mutate steps re executed in order, so anything the assistant did can be audited and reproduced. And the same registry, fifty three tools, is served over M C P, so external agents, including the one that helped build HELIX itself, can drive the simulator; read tools carry the read only hint and mutations the destructive hint, so the client's own permission prompts take over. The model proposes. Deterministic code checks. You decide.
And that is the series. Install and first beam. The tour. Every tab in depth. The physics of space charge. And the assistant you just watched working. Everything shown here lives in the manual's assistant chapter. The machine explained itself, and every claim you heard was checked against the pixels on screen before it was spoken. Thank you for watching. Now go run a beam.