Articles · No. 11
Abstract. On 17 October the talk of 15 October, 'Autonomy with a mandate and a memory', became a narrated page: the deck plays and a timed narration runs beside it, in three voices (a CEO, a CTO and a developer), so it can be watched with no sound. Every paragraph is timed to what is on screen and carries the notes it was written from. It is also the script for a voiceover video. Four ruv.sgit runs built it (r16 to r19), and one of them added a read-aloud mode that uses the browser's own voice. This article describes the page, how the narration was written, and how that voice works: where it comes from on each platform, whether it can be saved, whether Playwright can record it, what is free to use and what is not, and what to do for a recorded voiceover.
Written by Claude (Claude Code) from the session, its run records, release notes and a web search made for this article; reviewed by Dinis. Numbers come from files in this repository, and the article names them. Every claim about the web has a link to its source; where no primary source was found, the article says "unconfirmed". This is not legal advice.
On 15 October Dinis gave the talk Autonomy with a mandate and a memory at Agentic Engineering Live (Agentics Foundation London) from the player described in article No. 7. The deck is talk/talk-10.json: 26 timed beats, 698 seconds, so 11 minutes 38 seconds. Two days later, in a voice memo, he asked for "a separate page that is a text narrative of the presentation, because I want to make a video with voiceover of it", in three personas, "executive, strategic, very technical", and added: "I should be able to watch with no sound: press play and see the text explaining what is happening on screen, synchronised with it, from beginning to end" (poc/ruv-sgit/runs/r16-narration.spec.json).
That page is talk/narration.html. The deck plays in the page, and the narration for that second sits beside it, with its words lighting up at reading pace. The three narrations come to 1,338 words (CEO, 60 paragraphs), 1,334 words (CTO, 66 paragraphs) and 1,449 words (developer, 93 paragraphs), counted by site/build/narration_check.py. They are the script for the voiceover video, and, with read-aloud, a free preview of how that video will sound.

Dinis tried the first version on his iPad and sent a screenshot: the video was in the middle and the text at the bottom, which "keeps my eyes moving up and down, shifting context" (r18-layout.spec.json). So the page now has four layouts, picked from the bar and remembered:
| Layout | What it does | Where |
|---|---|---|
| ◧ text left (default) | The narration in a column left of the deck, the same height as the deck | Screens 900 px and wider |
| text right ◨ | The same, on the right | Screens 900 px and wider |
| ⬒ text top | The narration above the deck like captions, in a box of fixed height so the deck does not jump; in All three the box grows to fit | All screens, phones too |
| below | The narration under the deck, as in the first version | All screens |
On narrower screens text left and right are hidden. A link can set the layout with ?layout=top|left|right|below, the persona with ?p=ceo|cto|dev|all, and show the notes with ?notes.

The bar has CEO, CTO, Developer and All three. Each narration has a one-line voice of its own (from the voice field of each file):
All three shows them side by side, or stacked in the side column: the best way to see one slide told to three readers.

The page splits the current paragraph into words and darkens them at 150 words a minute from the moment the paragraph starts on screen. With the sound off, the dark words show where a voice would be: karaoke for a narration.
Tick show notes and each paragraph shows three lines: On screen (what the slide shows at that moment), From (the speaker's line, a cue or a step label it was written from) and Sources (the file behind every number). This was in the voice memo: "for every paragraph also the notes that created that paragraph."

Under the deck is the whole script, slide by slide. Each slide starts with what Dinis said on the day, in italics, followed by the narration's paragraphs with their times. Click a paragraph and the deck jumps there. With follow the deck ticked, the pane scrolls to keep the current paragraph in view and highlights it. If you scroll the pane yourself, it waits four seconds before it takes over again.

In All three, each button saves three files. Space plays and pauses (unless a button or a field has focus). The deck's own controls and keys still work: slide, step, speed, the slide picker. ▶ also scrolls the page so the deck and the text are both in view.

The narration came from a ruv.sgit run, like everything on this site: a Ruflo hive (MIT, by rUv / ruvnet) coordinating Claude Code workers, each delivering to its own branch of an ephemeral sgit vault. Run r16-narration had four workers: three writers (ceo, cto, dev), each a Claude Code subagent, and one builder, the page, done by the conductor (the main Claude Code session). The vault was opened at 12:22:48 on 17 October, closed at 12:33:58 and deleted two seconds later (site/data/vaults.json).
| Worker | Tokens | Tool uses | Wall time | Delivered |
|---|---|---|---|---|
| ceo | 100,124 | 10 | 173 s | ceo.json, 28,233 bytes |
| cto | 117,116 | 11 | 205 s | cto.json, 31,167 bytes |
| dev | 139,514 | 22 | 304 s | dev.json, 35,173 bytes |
| page | not metered separately | 7 files, 209,852 bytes |
The run's ledger entry also records its checks: 40 text fragments from the delivered files were searched for in every byte the server stored, with 0 found; a fresh clone matched; and after the delete, 0 store paths were left and a clone with the key failed.
The three writers shared one brief (poc/ruv-sgit/runs/r16-narration.brief.md). Its main points:
site/talk/narration/beats.json: every beat with its timing, the speaker's line and cue, the live page's steps with their times, and the page's visible text; plus the timeline, the slides, the data files and the earlier articles.site/build/narration_check.py enforces this: every beat present and in order, times increasing and inside their beat, notes with "screen" and "from", and each paragraph fitting its slot. Today it reports all three as ok.So what the writers left out is anything they could not trace to a file. The run did not record a list of omissions, so this article cannot give one.
One problem appeared at once. Several slides read the live ledger, data/vaults.json, and it keeps growing: it had 22 runs when this article was written. A narration that says "medians of three hundred eighty one operations" (the developer, slide 6) would soon disagree with the slide.
The fix is a pinned snapshot. The narrated deck loads with ?ruvledger=narrated. The player passes that on to every live slide, and assets/clock.js, which every live slide already loads, rewrites any fetch of data/vaults.json to data/vaults-narrated.json. That file holds the 15 runs the narration describes, as of 16 October at 14:41 UTC. The narrated deck shows the numbers its narration describes, while the main talk keeps showing the live ones.
The deck is the real player (talk/player.html) in a frame, opened with ?embed&auto&solo. Run r16 gave the player a small bridge for this. When it is inside a parent page, it posts its clock to that page ten times a second (the time, whether it is playing, the speed, the current beat). It also accepts play, pause, seek and rate commands, from its parent only, and only from the same origin. ?solo keeps it out of the presenter/audience window sync, so a narrated deck in one tab does not drive the talk in another. The page carries the clock forward between reports, which is why the words can light up smoothly.
Each later change was a run of its own, with one builder (the conductor, not metered separately) and its own ledger entry and release:
| Run | Dinis's feedback | Result | Release |
|---|---|---|---|
| r16-narration | the voice memo above | the page, three narrations, the bridge, the snapshot | v0.1.35 |
| r17-voice | "yes, use the browser built-in voice, I want to see how it works; do that before creating the text to audio" | 🔊 read aloud and a voice picker | v0.1.36 |
| r18-layout | the iPad screenshot: text beside the deck, swappable | text left, text right, below | v0.1.37 |
| r19-top | "that worked great; also add the experiment of putting the captions at the top" | text top | v0.1.38 |
This is the part Dinis asked about most: "I was not aware that was possible and I'm curious how it works."
All modern browsers have a built-in text-to-speech interface, window.speechSynthesis, part of the Web Speech API. A page creates a SpeechSynthesisUtterance with the text, and optionally a voice, language, rate, pitch and volume, then calls speechSynthesis.speak(). getVoices() lists the voices available. The browser hands the work to a speech engine. In MDN's words, "most OSes have some kind of speech synthesis system, which will be used by the API for this task as available" (MDN, Using the Web Speech API).
It is widely supported. caniuse puts it at 95.91% of global usage (StatCounter data for September 2026): Chrome, Edge, Safari, Firefox, Opera, iOS Safari, Samsung Internet and Chrome and Firefox for Android (caniuse). It is not a formal W3C standard, though. The specification is a Draft Community Group Report of the W3C Audio Community Group (spec).
The read-aloud code in talk/narration.html is about 40 lines. It does six things:
The voice picker lists the English voices (or all voices, if there are none in English), waits for the voiceschanged event because voices load asynchronously in Chrome (MDN), and remembers your choice.
What we tested, and what we did not. Our automated tests run headless Chromium on Linux, which has no voices. So the test script replaces speak, cancel, pause and resume with a stub that records what would have been spoken, at what rate and when. That checks the logic: which paragraph, from which word, at what rate, and what happens on a seek. It does not check the sound. We never heard it in our own tests: the first time it speaks with a real voice is in a reader's browser, so how it sounds depends on that reader's device and the voice they pick.
No. It works wherever the browser has voices, but the voices differ by platform and browser:
| Platform and browser | Where the voices come from | Local or online |
|---|---|---|
| macOS and iOS (Safari; also Chrome) | Apple's system voices | Local |
| Chrome on Windows, macOS, ChromeOS | The operating system's speech engine (SAPI 5 on Windows) (Chrome docs, chrome.tts); this page documents the extension API, and that the web API uses the same back end is unconfirmed | Local |
| Chrome, "Google …" voices | Added by Chrome when online; secondary sources only (thevalleyofcode, flaviocopes) | Online |
| Edge, "Microsoft … Online (Natural)" voices | "Powered by Microsoft Cognitive Services" and exposed "through the JavaScript SpeechSynthesis API" (Microsoft Edge blog) | Online |
| Edge, other voices | The Windows SAPI voices | Local |
| Android Chrome | Reported to use the device's Android TTS engine (unconfirmed) | Usually local |
| Linux (Chromium, Firefox) | speech-dispatcher, which usually drives espeak-ng (Chromium source); without it, there are no voices (Debian bug 809720) | Local |
That iOS Chrome gets the same voices as Safari, because every iOS browser uses WebKit, is our reasoning; no primary source was found. Whether Edge or Chrome list the on-device Windows 11 "Natural Narrator" voices is also unconfirmed.
Each voice says which kind it is: localService is true when "supplied by a local speech synthesizer service", and false for "a remote speech synthesizer service" (MDN, localService).
The privacy point. A local voice runs on the device; the text stays there. An online voice cannot work without sending the text to the vendor's server (Google's for Chrome's "Google" voices, Microsoft's for Edge's "Online" voices). We found no Google or Microsoft document that says what is sent, logged or kept (unconfirmed). For this page that is harmless, because the narration is public. For a page that reads private text aloud, the page should offer only voices with localService === true. narration.html does not filter on this today.
Not from the page. The API can speak, cancel, pause, resume and list voices. It has no audio stream or buffer a page could record (spec). Sending its sound to a chosen output has been an open request for years (W3C mediacapture-output #102).
What does work:
say -o out.aiff "text" writes an audio file, and say -v '?' lists the voices (say(1)). On Windows, .NET's SpeechSynthesizer.SetOutputToWaveFile writes a WAV with the SAPI voices, not Edge's online voices (Microsoft Learn). On Linux, espeak-ng -w out.wav "text" (espeak-ng; check --help for the flag).getDisplayMedia({audio: true}) plus MediaRecorder, with caveats. The user must pick the source in a prompt. MDN warns that "Capturing audio is always optional", so the stream may have no audio track (MDN, Using Screen Capture). On most platforms the operating system plays the speech, not the tab, so it may not be in the tab's audio at all. That is unconfirmed; test before relying on it.Before you save anything, see the licence section below. Being able to record a voice does not mean you may publish it.
No, for two reasons.
The pipeline that works has three steps:
.vtt download is the input: each cue already has its text, its start and its end.Community tools already follow this pattern: playwright-recorder-plus "captures video frames only. Audio is added by scheduling clips… which ffmpeg muxes in afterward" (repo), and playwright-recast adds a TTS voiceover from subtitles (repo).
There is a distinction to get right here.
Free and fine: a visitor's own browser reading a page aloud, on the visitor's own device. That is what narration.html does. We distribute text and code. The visitor's device makes the sound with voices it already has, and no audio file is published.
Not fine without checking: recording a system voice and publishing the recording. Apple's licence for macOS Sequoia, section 2.F, "Voices; Live Captions", says:
"you may: (i) use the system voices included in the Apple Software ("System Voices") (1) while running the Apple Software and (2) to create your own original content and projects for your personal, non-commercial use; … No other creation or use of the System Voices, Live Captions or Personal Voice is permitted by this License, including but not limited to the use, reproduction, display, performance, recording, publishing or redistribution of any of the System Voices, Live Captions or Personal Voice in a profit, non-profit, public sharing or commercial context."
(macOS Sequoia licence, PDF; older macOS licences have the same clause, for example 10.7.2.) A visitor's Mac speaking our page is "use while running the Apple Software". Running say -o and putting the file in a video on a public site is "recording, publishing … in a … public sharing" context, which the licence does not permit. That is our reading, not legal advice.
For Microsoft's Edge online voices, the Windows voices and Chrome's Google voices, we found no licence clause either way: unconfirmed. Some libraries call Edge's Read Aloud service directly, but they use an endpoint Microsoft does not document (edge-tts-browser README); avoid them for anything published.
So read-aloud on a page is free, and it can go on many more pages. A published voiceover video needs a voice whose licence says yes.
We found no adoption figures, so we give none. The 95.91% above is the share of browsers that support the API, not the share of sites that use it. These are the best examples we found:
WebSpeechSynthesisAdapter so AI chat replies can be read aloud.A recorded voiceover for the video. The script and the captions are ready; what is missing is a voice we may publish. The options:
rhasspy/piper (MIT) was archived in October 2025, and development moved to OHF-Voice/piper1-gpl, which is GPL-3.0 (rhasspy/piper, OHF-Voice/piper1-gpl). Each Piper voice model has its own licence, so read the voice's model card before publishing; we have not checked any.Either way, the pipeline is the one above.
Read-aloud on more pages. This is the free part, and it travels well. The same 40 lines, minus the deck clock, can put a "read aloud" button on every article on this site and on sgit.ai: one utterance per paragraph, the paragraph highlighted as it is read, a voice picker, and the iOS tap unlock. Two improvements are worth making as we do: offer local voices first (localService) and say when a voice is online, and keep the word highlighting, because it helps readers whether the sound is on or not.
The narrated talk is at ruv.sgit.ai/talk/narration.html. Press ▶, pick a voice, and tick read aloud.