AgentSee

Hove & London Founded 18 August 2026 Issue No. 8 · Free, obviously

Two clicks a person,
and the rest is a diagram.

Issues No. 5 and No. 6 told the stories of building it. This is the map: every stage from the studio to nine in the morning, what each one does, where it runs, and why it is that way. Five episodes have been through it. The judgement is still ours, and so are the approvals; the one hand step we would rather not have is the download, and the map says why.

The map: from the studio to the platforms, by stage, and where each stage runsThe studioRiverside, their cloudRecordeach person recorded locally; 1080p set by hand before the buttonDownloadtwo clicks a person: the Aligned video and the Raw audio, to a folderThe workstation, the wordsHove: 32 threads, a 2080 Ti, Ubuntu; three pinned virtual environmentsingesteach WAV placed inside itsown video's audio bycorrelation; manifest.jsonfillers, ermGPUWhisper asked for averbatim transcript: everyum its own token; seededalignGPUwav2vec2 finds where eachword is; ghosts dropped,skipped replies refilledread the transcriptchapters quoted, clipschosen, notes written: asession with the modelcutedl.json: fillers,stammers, pauses, each edgeon a 2 ms envelope; sixvariantsThe workstation, the picture and the mastersNVENC on the card; x264 the slow fallbackcardstitle, chapter andend cards from thesite's CSS, throughChromeassemblegate by words, match,-16 LUFS; the mp3with chapters, themp4, captions,qc.jsonclipsvertical, 4:5,captions lit word byword; a poster each,PNG and JPEGreleasenotes, chapters inthree shapes, VTT,art, a hash per file,the day planapprovethe number minted;each guest's approvalchecked; refuses on awarningstagemasters to thearchive, public filesto the media host, byhashCloudflareR2 in western Europe, two Workers, KV, Pagesthe media hostmedia.agentsee.work: themp3, the clips, the art,transcripts, chaptersmedia Workerone row per request; alisten by the IAB's rule,no cookieshort linksagentsee.work/p/<id>: a KVlookup, a row, a 302 to themomentthe sitefeed.xml for Apple andSpotify, the episode page;written by site.py on thedaythe archiveprivate: the tracks, theedit as data, everydeliverable, the ledgernightlyThe boxInfomaniak, 2 vCPU, 4 GB; two containers behind a Tunnel; deployed by a green tickingestrelease.json andstaged.json from thearchive into the ledgerplanone post per asset peraccount; a short linkminted for eachsnapshot, 03:50the ledger copied to thearchive; a rebuilt boxrestores from itcollect, 05:30the edge's rows intolistens and clicks; eachplatform's counts, datedpublisha worker every minute: whatis due, through one adapterper platformThe platformsthe episode on its day, a clip a day after; Apple and Spotify read the feedYouTube06:00; uploadedprivate the daybefore, publishAt;captions, playlistX09:00; the clip bychunked upload; asingle-use refreshtokenBluesky09:00; the videoservice; links asfacets; 300graphemesMastodon09:00; anidempotency keyper attempt; 500charactersThreads09:00; Metafetches the file;a sixty-day token,refreshedInstagram09:00; a Reel withits poster; asystem-user tokenLinkedIn08:30; threecards; each postwritten by aperson, bydecisionnightly The map: from the studio to the platforms, by stage, and where each stage runsThe studioRiverside, their cloudRecordeach person recordedlocally; 1080p set byhand before thebuttonDownloadtwo clicks a person:the Aligned video andthe Raw audio, to afolderThe workstation, the wordsHove: 32 threads, a 2080 Ti, Ubuntu; three pinnedvirtual environmentsingesteach WAV placedinside its ownvideo's audio bycorrelation;manifest.jsonfillers, ermGPUWhisper asked for averbatim transcript:every um its owntoken; seededalignGPUwav2vec2 finds whereeach word is; ghostsdropped, skippedreplies refilledread the transcriptchapters quoted,clips chosen, noteswritten: a sessionwith the modelcutedl.json: fillers,stammers, pauses,each edge on a 2 msenvelope; sixvariantsThe workstation, the picture and the mastersNVENC on the card; x264 the slow fallbackcardstitle, chapter andend cards from thesite's CSS, throughChromeassemblegate by words, match,-16 LUFS; the mp3with chapters, themp4, captions,qc.jsonclipsvertical, 4:5,captions lit word byword; a poster each,PNG and JPEGreleasenotes, chapters inthree shapes, VTT,art, a hash per file,the day planapprovethe number minted;each guest's approvalchecked; refuses on awarningstagemasters to thearchive, public filesto the media host, byhashCloudflareR2 in western Europe, two Workers, KV, Pagesthe media hostmedia.agentsee.work:the mp3, the clips,the art, transcripts,chaptersmedia Workerone row per request;a listen by the IAB'srule, no cookieshort linksagentsee.work/p/<id>:a KV lookup, a row, a302 to the momentthe sitefeed.xml for Appleand Spotify, theepisode page; writtenby site.py on the daythe archiveprivate: the tracks,the edit as data,every deliverable,the ledger nightlyThe boxInfomaniak, 2 vCPU, 4 GB; two containers behind aTunnel; deployed by a green tickingestrelease.json andstaged.json from thearchive into theledgerplanone post per assetper account; a shortlink minted for eachsnapshot, 03:50the ledger copied tothe archive; arebuilt box restoresfrom itcollect, 05:30the edge's rows intolistens and clicks;each platform'scounts, datedpublisha worker everyminute: what is due,through one adapterper platformThe platformsthe episode on its day, a clip a day after; Apple andSpotify read the feedYouTube06:00; uploadedprivate the daybefore, publishAt;captions, playlistX09:00; the clip bychunked upload; asingle-use refreshtokenBluesky09:00; the videoservice; links asfacets; 300 graphemesMastodon09:00; an idempotencykey per attempt; 500charactersThreads09:00; Meta fetchesthe file; a sixty-daytoken, refreshedInstagram09:00; a Reel withits poster; a system-user tokenLinkedIn08:30; three cards;each post written bya person, by decisionnightly
The whole of it, by stage, in the order it runs. Each band is a machine: Riverside's cloud, a workstation in Hove, Cloudflare, a small box at Infomaniak, and the platforms. A box with an orange edge is a step a person takes. Everything else is a script reading a file the last one wrote.

01 — The premise

Every stage writes a file, the next one reads it, and a change of mind is a re-run.

That was the rule in October, when the first episode went through it in three days, and it has not needed changing. What has changed is everything around it: four more episodes, from eight minutes to fifty-two, out on five Tuesdays in a row; twenty-seven clips; an engine on a rented box that posts to six platforms without anyone awake; a private archive that holds the masters; and a recording service that took a feature away in the second week of November. Issue No. 5 is the story of the ums and Issue No. 6 the story of the token. Neither is a map, and by the fifth episode a map was what we wanted ourselves, so this is it, drawn to be read.

Four machines run it. Riverside records, in its cloud and on each person's own computer. A workstation in Hove, thirty-two threads and a 2080 Ti under Ubuntu, does the production: the transcription, the cut, the renders. Cloudflare holds two buckets, one private and one public, and runs two small programs at the edge and the site itself. And a box at Infomaniak, two virtual CPUs and four gigabytes for about five euros a month, runs the engine that does everything after staging, in two containers behind a tunnel, deployed by a green tick on the main branch. The code for all of it is one public repository; the episodes are not in it, and never will be.

Read the map top to bottom. A box with an orange edge is a step a person takes, and there are four: the two downloads, the reading of the transcript that chooses the chapters and the clips, the approval that mints the episode's number, and the three LinkedIn posts. A fifth the map does not draw: a merge on the morning of release, which publishes the page and the feed. The rest of this issue walks the bands in order and says, for each stage, what it does, how, and what decision put it there. The decisions are the point. Most of them were taken because the obvious thing was measured and found wanting, and the measurements are in the repository next to the code.

02 — The studio

Riverside records well, exports grudgingly, and moved the line in November.

Riverside does one thing we could not do better: it records each person locally, on their own machine, so the tracks are clean of each other, and uploads them as the session goes. For a two-person show that is the whole reason to pay for it. Its editor removes fillers and pauses genuinely well when it works; we could not get it to stay stable long enough to trust it with an edit, and an edit that lives in someone's browser is not one you can re-run, so the edit is done here, from the same material, as data. Its transcript is by the sentence, with no word timing, and the cut needs words. So from the recording we take two files a person and nothing else: the Aligned video, a constant-frame-rate MP4 with that person's own audio inside it and a pad at the front if they joined late, and the Raw audio, the WAV. A folder of those is what the pipeline takes.

Until November it took something else. Riverside's timeline export, one ZIP with the same tracks and a Premiere XML stating where each one starts, was on the plan we are on, and episodes 0 to 3 were cut from it. The offsets were the useful part: two frames on episode 0, none on episodes 2 and 3, and on an edited timeline the leading pause was trimmed from every track by a different length, which once put one voice a second and a half late for a whole episode until ingest learned to read the alignment at a time all the tracks covered. On 9 November the export was behind the plan above ours. We would not upgrade for it, so ingest now measures the offsets itself. A person's WAV is the same recording as the audio inside their aligned video, behind the same pad, so the WAV is found inside it by cross-correlation: the whole file at four kilohertz, then three one-minute windows at sixteen that have to agree. On episode 4 both WAVs sat at 0.00 milliseconds in all three. It has to be the Aligned video and not the Raw one, because for someone who joined late only the aligned file carries the wait, and ingest warns when the videos differ in length. The frame or two the XML sometimes carried is inside the delay of the call itself, and nobody will hear it.

The rest of the grudge, for the record. The API that would list a recording and hand over each track behind a signed link is for select Business accounts, through a customer success manager, at a custom price; one third-party figure puts it near five thousand dollars a year, against four hundred for the plan with the MCP, whose sixty-nine tools include none that hands over a file. The webhooks cover webinars only. The terms forbid automating the download button. The link the button makes for a video is signed for sixty seconds, so even the cheapest automation, pasting that link into the engine to fetch cloud to cloud, has to open the request within the minute; the raw audio's link is the opposite kind, good for three years and therefore a secret. The studio records at 720p unless somebody sets 1080p before the button, every time; the cloud recording of everyone together is deleted after three months; separate-track downloads stop when the plan's hours are spent. None of it is malicious. It is a service whose roadmap points at its own editor, and ours points away from it. The decision, taken twice, was not to pay for the API and not to build a recorder. Two clicks a person stays.

Two files a person, and the WAV placed by its own video's audio0 s20 s40 s60 sone clockAbrarAligned videoRaw audiofound at +0.00 ms: the whole file at 4 kHz,then three one-minute windows at 16 kHz thathave to agreeJamesAligned videoRaw audiofound at +0.00 ms. The frame or two the oldXML sometimes carried is inside the call'sown delayA guest who joined lateAligned videoRaw audiothe waitthe aligned video carries the wait, so theWAV lands where they spoke; a Raw videowould start at 0 and lose itvideo: constant frame rate, their own audio insideWAV: recorded on their machine, 44.1 kHz, the master
Two files a person on one clock. The WAV is found inside its own video's audio, over the whole file and then in three windows that have to agree. For a guest who joined late, the aligned video carries the wait; a raw one would put them at the start.

03 — The words

Whisper hears the sentence and the cut needs the um, so three models read every track.

Whisper writes readable text, which means it leaves most ums out and stretches the word before over them. Asking it for the fillers by name cost it a third of the real words. A tool called erm asks it for a verbatim transcript instead, and on these tracks that hears every um as its own token and loses nothing: 960 words on James's track against our 935, 68 fillers against our 41. It is also where the pipeline became reproducible. Whisper samples where it is unsure, and seven unseeded runs on episode 0 gave one track five different readings of one murmured spot; since 7 November the seed is fixed and three runs come out byte for byte the same, on this machine. Another GPU may choose other words at such a spot, which is why a chosen edit is always re-rendered from the cut and never from the transcription.

Then the times. Whisper's word times on this material run up to half a second early around fillers, and the two transcripts that agreed to ten milliseconds agreed because they were the same model making the same mistake. So a second model places the words: a forced aligner, wav2vec2 with a character-level classifier, given the words and asked only where each one is. Its first version worked in twenty-second chunks and forced a word two seconds out onto the wrong sound; it now scores the whole track in overlapping windows and runs one Viterbi pass over the lot, with no reference to Whisper's clock. Twenty seconds on the card. The same pass catches two faults in the transcript. Whisper writes "Thank you." into a gated speaker's silence; a word with no sound under it is a ghost and goes, and the same phantom said under the other person's voice is caught by Whisper's own doubt, the probability it gives each segment of not being speech, 0.7 to 0.9 on these against 0.04 on a sentence. And Whisper drops the odd short reply altogether, so every run of speech-level sound with no word for it is transcribed again on its own, and what comes back is added. Spelling is never prompted: a prompt with the show's vocabulary cost forty per cent of the words on episode 0, so "Agency" becomes AgentSee afterwards, by a list of fixes in the episode's file that is diffable and loses nothing. Episode 4's list has 229 of them.

The cut reads the aligned words and the audio, and removes three things: fillers, stammers, and pauses over 0.7 seconds, closed to 0.4, by default. None of the edges comes from the transcript. Every cut is placed on a two-millisecond energy envelope at the quietest moment nearby; a filler is the sound between its aligned neighbours; every word that stays owns the sound inside its span, and no rule may touch it; and a cut across the other speaker is refused where they have a word, or a third of a second of speech-level sound the transcript never wrote down, because a reply Whisper missed is worth more than an um. Each join gets its own crossfade, twenty milliseconds against a word and sixty across a pause, and the video is cut hard at the same frame. The acceptance test is not a transcript of the render, because Whisper hallucinates a filler at every abrupt join; it is each um's own audio, correlated against the render around its cut, and when a person doubts it, a short excerpt transcribed and read as a sentence. Where a chapter starts is not a property of the audio, so the chapters file quotes it, the first words of a section and the last words of the one before, chosen by reading; the tool finds the quiet point either side and drops whatever was said between, and a phrase it cannot find, or finds twice, stops it. Six variants of the whole edit are rendered as mp3s with their cut lists, and a person chooses by listening. We chose the tightest, and have kept choosing it.

From the tracks to the edit: what each stage reads, writes and runs onRaw audioone WAV a person,44.1 kHz, recorded ontheir own machinefillers.py, ermGPUWhisper with averbatim prompt:every um its owntoken, 68 against our41; seeded, so threeruns agree. 90 s forboth tracksalign.pyGPUwav2vec2, characterCTC, one Viterbi passover the whole track:where each wordactually is. 20 sghosts, refillsCPU'Thank you.' writteninto silence droppedby its own doubt andlevel; a replyWhisper skippedtranscribed again onits owncut.pyCPUfillers, stammers,pauses over 0.7 s;each edge on thequietest moment of a2 ms envelope;chapters by quotedwords. 4 sedl.jsonthe edit as data: thestretches thatsurvive, the cardsplaced; six variantsto listen to From the tracks to the edit: what each stage reads, writes and runs onRaw audioone WAV a person, 44.1 kHz, recorded on theirown machinefillers.py, ermGPUWhisper with a verbatim prompt: every um its owntoken, 68 against our 41; seeded, so three runsagree. 90 s for both tracksalign.pyGPUwav2vec2, character CTC, one Viterbi pass overthe whole track: where each word actually is. 20sghosts, refillsCPU'Thank you.' written into silence dropped by itsown doubt and level; a reply Whisper skippedtranscribed again on its owncut.pyCPUfillers, stammers, pauses over 0.7 s; each edgeon the quietest moment of a 2 ms envelope;chapters by quoted words. 4 sedl.jsonthe edit as data: the stretches that survive,the cards placed; six variants to listen to
From the tracks to the edit. Two of the six stages run on the card; the aligner is the one that put the ums where they are. Everything downstream, the captions, the gate, the clips, uses the aligned clock.

All of it runs on the workstation, in three virtual environments pinned by a full freeze of the ones the approved episodes were made in: erm with its own build of Whisper, the aligner with a GPU build of torch, and a small one for staging. On a thirty-two-thread machine with the 2080 Ti a nine-minute episode goes from the tracks to every deliverable in about nine minutes, two of them the animated cards: both tracks through erm at once in ninety seconds, the aligner in twenty, the picture in one encode on the card's own hardware encoder in under three, the clips in a pool alongside it. The hardware encoder is the difference between a pipeline and an evening: episode 1, forty-six minutes recorded, took forty-four to assemble on x264, thirty-five of them the two 1080p encodes, before the card took them over at a quantiser calibrated against x264 by signal-to-noise ratio. The long episodes' remaining cost is the audio stage, twelve minutes of loudness passes over the full length, and the next thing to look at. It also means every episode is made on one machine in one house, with a slow line out of it; the plan to change that is at the end.

Until an episode is staged, its masters exist on one machine in Hove.

04 — The picture, the mix and the masters

Levels are measured, not predicted, and nothing leaves the workstation until the hashes agree.

The cards come from the site. The title card, the chapter cards and the end card are rendered from the site's own CSS through headless Chrome, frame by frame, animated with the same chains that move the eye on the front page, so the show looks like the paper it belongs to and a change to the stylesheet changes the next episode. The opening is stated once: the sting lands on its tonic at 6.4 seconds with three beats of silence written for a title to resolve into, the first word arrives at six, the bed fades under it by twenty-four, and every one of those numbers is an argument with a default, not a decision made per episode at eleven at night.

The mix gates each speaker's track by their own words, plus any speech-level sound the transcript has no word for, never by a threshold, because a threshold gate breathes on a quiet speaker and a gate that opened only where the transcript said muted a reply Whisper had dropped. The gated tracks are matched, summed and brought to minus sixteen loudness units as a float file, peaks and all. Only after the cut is the dialogue compressed, gently, two to one with a slow release, because the limiter alone had been doing the levelling and was heard as the level ducking at every join; it runs after the cut so its state carries across every join. Then the whole mix is limited, normalised and measured: every file that ships is read back and its loudness and true peak written down, because the first time a level was predicted the normaliser had silently switched modes and landed two decibels short. The clips are vertical, two 1080 by 675 crops of a 720p frame filling a four-by-five band exactly, with the captions lit word by word on the aligned clock and a bar that follows who is speaking; each gets a poster as a PNG for the site and the same frame as a JPEG, the only cover Instagram takes.

The release stage renders nothing but a picture and makes everything a publisher needs from what the others made: chapters in the three shapes the directories read, from one list; the transcript as WebVTT with a voice tag per cue and as JSON for the page; the notes in the five tags Apple allows; artwork at 3000 square; a globally unique identifier minted once and kept, because a guid that changes is a duplicate episode in every listener's app; every file with its size, type, duration and SHA-256; and a day plan, the episode on its day and a clip a day after. An episode has no number until it is approved. The number is on the title card, the art, the YouTube title and the site, and a guest who never approved would leave a hole in the sequence or force everything after to be re-rendered, so approval mints it, one more than the highest in the archive, redoes the render with it, records who approved and when with the hash of every deliverable, checks each guest's signed approval of the round they reviewed, and refuses while the release carries a single warning.

Staging is the moment the masters leave the house. Everything goes to a private bucket in Cloudflare's western Europe region, which nothing serves: the tracks as downloaded, the edit as data, every deliverable, each review round, each guest's records. The public files, the mp3, the clips, the art, the transcripts and the chapters, go to a second bucket behind media.agentsee.work, because the pages' own host stops at twenty-five megabytes and an episode is fifty-five. Every object carries its SHA-256 as metadata, so a re-run puts only what changed, and the stage refuses an episode whose files are not the ones approved. Episode 4 was seventy-seven objects and 8.6 gigabytes, ninety minutes up a line that gives 1.6 megabytes a second, which is the best argument for the last section. Until it has gone, the masters exist on the workstation and nowhere else, and the operating notes are blunt: keep the download. After it, the archive is the master copy. The engine's ledger, a SQLite file on the box's root disk that a rebuild would wipe, is copied into the same archive every night at ten to four, and a rebuilt box restores from it; the mail server on the same box backs up nightly to a bucket of its own, the infrastructure's state lives in a fourth, and each bucket has a token that can reach it and nothing else, because one credential that can both delete the backups and rewrite the infrastructure is a poor blast radius. The box is disposable by design: destroy and apply is a legitimate first response to a broken one, and it is expected to work.

A script writes the feed and the pages from what was staged, and takes an episode only when its staging record matches the release and its release date has arrived, London time, so a merge made early publishes nothing. In front of the media host a Worker serves the files and writes one row per request, the file, the status, the bytes, the app, the country and a hash of the address keyed to the day, never the address; that row is what lets us count a listen the way the industry defines one, with no cookie, no script on the page and no third party. A second Worker answers the short links every post carries, writes the click down with the platform it came from, and sends the reader to the episode page, at the clip's moment if it was a clip.

Where the bytes live: the workstation until staging, then the archive and the media hostThe workstationbuild/episodes/<slug>/: source/ holds the tracks,then transcript/, edl.json and out/ with everydeliverable. Gitignored: the recipe is the repo,the episode is not. Until staging, the mastersare here and nowhere else.stagerefuses files whose hash is not the one approved;every object carries its SHA-256, so a re-runputs only what changed. Episode 4: 77 objects,8.6 GB, ninety minutes up a slow line.agentsee-podcast-archiveprivate, R2 in western Europe:sources/<slug>/tracks/, the edit as data, out/,each review round, guests/<id>/, and the engine'sledger each night. Nothing serves it.agentsee-mediapublic, media.agentsee.work: the mp3, the clips,the art, transcripts and chapters. Nothing goeshere that anyone may not download. The Worker infront counts.The box: ledger.sqliteon the root disk, so a rebuild wipes it; copiedto the archive at 03:50 and restored on a rebuiltbox. The mail server beside it backs up nightlyto a bucket of its own.the mastersthe public filesnightlyThe infrastructure's state sits in a fourth bucket, and eachbucket has a token of its own.
Where the bytes live. The workstation until staging; then a private archive for the masters and a public bucket for what anyone may download, with a Worker in front of it counting. The box's ledger goes to the archive every night.

05 — Nine in the morning

One post per asset per account, a short link each, and six adapters that know their platform's manners.

The engine learns of an episode from the archive: an ingest reads the release record and the staging record into its ledger, with the media host's address for every public file, and nothing after that needs the workstation. A plan then walks the release's day plan and, for each asset and each account that takes that kind of asset, makes one post: the text drafted from the release, the clip's hook and attribution or the episode's title and summary, cut to the platform's budget a sentence at a time with the link and the tags kept; the media named; the due time set to the plan's day at the account's hour; and a short-link id minted, e4xc02 for episode 4, X, clip 2, so every click back is counted at the edge and attributed to the post that earned it. Episode 4 is twenty-nine deliverables, thirty-nine posts and thirty-nine short links. A plan never touches a post that exists, so an edit survives a re-plan, and a post moves through a handful of states, planned, due, publishing, scheduled, published, by hand, failed, skipped, that the screens show and a person can push.

A worker runs the publisher every minute and sends what is due through one adapter per platform, each written against the platform's actual manners rather than its brochure. YouTube takes the episode and the clips the moment they exist, private, scheduled for six in the morning of their days: a resumable upload in eight-megabyte chunks, the captions, the thumbnail, the show's playlist; once the video is up nothing after it can fail the post, only leave a note, because losing the id would mean uploading two gigabytes again and publishing a duplicate; and the channel's daily cap is a hold, not a failure. X does not schedule, so it is posted to at nine, the clip through its chunked upload; its refresh token is single use and the vault item is the live copy, which was Issue No. 6. Bluesky gets the art as a blob on the account's own data server, a clip through its video service, and the link and the tags as facets over the UTF-8 bytes, or they would be plain text. Mastodon gets the file, polled while a video is processed, then the status with an idempotency key so a lost reply cannot post twice. Threads and Instagram are Meta's: a container with the text and the file's public address, which Meta fetches from the media host itself, a poll until it has, then the publish, with the container's id written down the moment Meta issues it so a retry finds a post that went through rather than making it twice. Threads runs on a sixty-day token the engine refreshes; Instagram on a system-user token that stands, and takes a clip as a Reel with the JPEG poster as its cover. LinkedIn is by hand for good, by decision: three cards at half past eight, one per person and one for the page, each there for the short link and the record, the post written by the person. Apple Podcasts and Spotify took the feed once, in October, and take each episode from it; their numbers come by a Java tool and a spreadsheet export, not an API, and that is a hand step still to automate.

Three rules round it off. A post whose hour passed more than six hours ago is not sent; if nothing was running that morning the posts wait on a screen for a person to send, move or skip, rather than going out in a bunch at the next start. At half past five the collector reads back what everything did, the edge's rows into listens by the industry's rule, one listener, one file, one day, a minute's worth of bytes, not a bot, and into clicks, and each platform's counts into dated rows per post, because a platform only ever says a running total and X forgets after thirty days. And every credential the engine holds is a reference in a committed file, resolved from the password manager when the container starts under an account made for the box; the ones it writes, the rotating tokens for X, Linear and Threads, go back to the vault before they are used. Beside all that the engine tells the episode's Linear issue what happened, mails the hosts when a person is needed, and shows its screens: the episodes, the plan as a calendar, what is by hand today, reach per episode and per post with the last week's share, the audience by app and country, the guests, and its own health, down to the commit it is running and the last deploy's outcome.

Release day on the box: what runs when, London time03:0004:0005:0006:0007:0008:0009:0010:0003:50 snapshotthe ledger to thearchive05:30 collectthe edge's rows into listensand clicks; every platform'scounts, as dated rows06:00 YouTube, and the feedthe episode and its clips gopublic, uploaded private the daybefore; the feed's date is06:00, so Apple and Spotifyfollow08:30 LinkedInthree cards: the shortlink and the file; thepost written by aperson09:00 the five at oncethe art and the episode'stext, each in itsplatform's way; a clip aday after, same hoursA post whose hour passed more than six hours ago waits for a person instead of going out in a bunch. Release day on the box: what runs when, London time03:50 snapshotthe ledger to the archive05:30 collectthe edge's rows into listens and clicks; everyplatform's counts, as dated rows06:00 YouTube, and the feedthe episode and its clips go public, uploadedprivate the day before; the feed's date is06:00, so Apple and Spotify follow08:30 LinkedInthree cards: the short link and the file; thepost written by a person09:00 the five at oncethe art and the episode's text, each in itsplatform's way; a clip a day after, same hoursA post whose hour passed more than six hours agowaits for a person instead of going out in a bunch.
Release day on the box, London time. YouTube's posts were uploaded private the day before and go public at six with the feed; the five accounts that do not schedule are posted to at nine; LinkedIn is three cards for people. A clip a day follows.

06 — What stays by hand, and what is next

The downloads, the reading and the approvals are ours. The GPU is the next thing to rent.

Five hand steps, then, and each is there for a reason we can name. The two downloads a person, because the recorder sells automation at a price that buys a year of the whole pipeline's compute. The reading of the transcript that quotes each chapter's first words, chooses the clips and writes the notes, because where a section begins and which passage stands alone are judgements, and the one time a rule placed a card it landed mid-sentence. The approval, because it mints a number that is then on everything and is signed for. The LinkedIn posts, because few of them matter and each should be written by a person. And the merge on the morning of release, because a push to the site publishes it, and a person should press that. Everything else that is still typed is typed only because it has not been moved yet: the staging command, the engine's ingest and plan, the directory links, the site's pull request.

The plan to move it was written on 4 November, as a project of twelve issues, and starts from the slow line: 8.6 gigabytes leave the workstation at 1.6 megabytes a second, and a guest's episode is three runs of the pipeline, each a reason to be at that keyboard. So the stages stay as they are and move into one container image, with CUDA, the three environments, ffmpeg with the hardware encoder, headless Chrome, the fonts and the model weights baked in and pinned by digest. The engine rents a GPU for the length of a run, an L4 at Infomaniak at about twenty-nine cents an hour, on the same account as the box and already in the privacy notice, hands it the job with signed links and no long-lived credential, and destroys it when the run ends or its deadline passes; a stopped instance there still bills its card, so destroy, never stop. Every stage reads its inputs from the archive and writes its outputs back by hash, so a run resumes from the last complete stage on a fresh instance. A one-hour episode is thirty to sixty minutes of an L4, under thirty cents, so a spot market saves pennies; what needs constraining is a runaway, which is a deadline on every run, destruction on exit and a monthly ceiling. The engine keeps a production ledger and a screen with the actions, and the judgement steps become proposals from the model that a person edits and approves on a screen before the render. Decided: no Business API, no recorder of our own, and Cloudflare stays the archive and the edge, since its containers have no GPU. Still to decide: Infomaniak on demand or spot elsewhere, how much judgement to automate first, and whether the engine may open pull requests. The first issue is the paste: a download link into the engine, fetched cloud to cloud, with the request opened inside Riverside's minute.

The plan: the same stages on a rented GPU, marshalled by the enginethe engine starts a runa Production screen:start, retry a stage,cancel, destroy; adeadline on every run anda monthly ceilinga GPU for the runInfomaniak, the box's ownaccount: an L4 at about€0.29 an hour, destroyedon exit, never stoppedone imageCUDA, the three venvs,ffmpeg with NVENC,headless Chrome, the fontsand the model weights,pinned by digestthe stages, unchangedeach reads the archive andwrites back by hash, so arun resumes from the lastcomplete stagea person, on a screenchapters, clips and notesproposed from thetranscript; edited andapproved before the render The plan: the same stages on a rented GPU, marshalled by the enginethe engine starts a runa Production screen: start, retry a stage,cancel, destroy; a deadline on every run and amonthly ceilinga GPU for the runInfomaniak, the box's own account: an L4 atabout €0.29 an hour, destroyed on exit, neverstoppedone imageCUDA, the three venvs, ffmpeg with NVENC,headless Chrome, the fonts and the modelweights, pinned by digestthe stages, unchangedeach reads the archive and writes back by hash,so a run resumes from the last complete stagea person, on a screenchapters, clips and notes proposed from thetranscript; edited and approved before therender
The plan, not yet built: the same stages in one image on a GPU rented for the run, checkpointed through the archive, marshalled from the engine's screens. Specified 4 November; the provider and the amount of judgement to hand over are still to decide.

What this map leaves out is the other half of the engine, the guest's office at see.agentsee.work: a door, a release to sign, a conversation with a model that turns an idea into a run-sheet, a calendar, and a review page where a guest hears the cut, leaves notes at the moment they are about, and signs the approval the pipeline then insists on. That is a map of its own, and it is Issue No. 9. The next one is the one the register has held open since September, the first conversation with someone who disagrees; the sceptic has said yes. Until then the map above is the state of things on 13 November, five episodes in, and the diagrams are drawn from the same files the scripts read, so when the pipeline moves, the picture can be redrawn rather than retouched.