A Show of Your OwnJune 2026

Why own it

Reading Google, Generate an Audio Overview in NotebookLM; ElevenLabs, Text to Speech.

1.1The same two voices

NotebookLM's Audio Overview takes the sources you upload and produces a polished conversation between two AI hosts. As a way to absorb a dense document while you do something else, it is genuinely good, and this guide is not an argument against using it for that. The trouble shows up only with repetition. The hosts are a fixed pair in fixed voices, and the banter follows a house cadence, so episode after episode arrives in the same register. The first one is a small delight; by the fifth, the sameness is doing the opposite of holding your attention — the voices blur together and you stop listening closely. A podcast lives or dies on whether each episode feels like its own thing, and a tool that hands you one voice forever is working against that.

1.2What it fixes in place

The sameness is not a setting you can turn off; it falls out of what the vendor box keeps fixed. There are no custom or own voices — you take the pair you are given. The result cannot be edited after it generates; your only recourse is to regenerate the whole thing. Length is governed mostly by how much source you feed it rather than a control you set, and coverage of the points you care about is not guaranteed. Customization is a single instruction before generation, not a script you author. Each of these is reasonable for a summarizer; together they mean the one thing you cannot do is make the show yours.

The trade is plain once named: renting buys polish and speed at the price of a single, repeating sound. For a study aid that is the right bargain. For a show you publish under your own name — where the voices, the rhythm, and the sense that this episode is not the last one are the work — the fixed knobs are exactly the ones that matter.

Two models, two jobs

Reading ElevenLabs, Text to Speech; Anthropic, Messages API.

2.1The shape

The pipeline is two AIs doing opposite jobs. Claude is the writer — it invents the hosts, decides who says what, in what order, in what tone. ElevenLabs is the speaker — it reads the finished script aloud in the voices you chose. Between them sits the script, and the script is the artifact that makes the difference. In the vendor box it never exists as anything you can touch; split the job in two and it becomes a plain file.

2.2Why the seam matters

Because the script is a file, the pipeline is inspectable and re-runnable at every stage. A clumsy exchange is a text edit, not a reroll of the whole show. A host's stance is a line you wrote, not a hope. The episode is exactly as long as what you put on the page. This is the same idea this series keeps returning to — own the file, do not rent the platform — applied to audio: the place the all-in-one tool hides is the place you get to work.

Personas first, then the script

Reading Anthropic, Messages API; ElevenLabs, Eleven v3 audio tags, the tag vocabulary the script targets.

3.1Build the cast before the script

The mistake is to jump straight to "write me a two-host episode." What makes a show listenable is the relationship between the hosts — the back-and-forth, the affectionate friction, the way one drags the other back on topic — and that has to be designed before any line is written. So the first artifact is not a script but a persona bible: a short document naming the two hosts, giving each a backstory and a role in the conversation (the curious one who asks the naive question; the dry skeptic who has read the paper), the texture of how they speak, and the dynamic between them. The most useful trick is to model it on a real show whose banter you already enjoy — not to copy it, but to borrow its rhythm. Write that bible once and reuse it across episodes; it is what gives a feed continuity even as the topics change.

3.2The script as structured turns

With the bible in hand, have Claude write the episode as structured turns — a list of objects, each with a speaker and a line — so the synthesis stage can consume it without parsing prose. Put the delivery cues inline, as Eleven v3 audio tags in square brackets, so the writer decides not just the words but how they land:

[
  {"speaker": "maya", "text": "[curious] So why not just use NotebookLM?"},
  {"speaker": "dev", "text": "[laughs] Because every episode sounds the same."}
]

To produce it, pass the persona bible as the system prompt and ask for JSON only. The bible carries the cast; the user message carries the source for this episode:

import json, anthropic

client = anthropic.Anthropic()             # reads ANTHROPIC_API_KEY

msg = client.messages.create(
    model="claude-opus-4-8",
    max_tokens=4000,
    system=PERSONA_BIBLE,                  # the cast, the dynamic, the format
    messages=[{"role": "user", "content": SOURCE_TEXT}],
)

turns = json.loads(msg.content[0].text)    # [{"speaker": ..., "text": ...}, ...]

The brief is where editorial control lives. Set the length and pace explicitly; the model writes to a target far better than the vendor box toggles to one. Say what to cover and what to skip. Require that every claim trace to the source you handed over — the script is where you decide what is true, so keep the writer on the material and read the draft before a single word is voiced.

Casting the voices

Reading ElevenLabs, Text to Speech best practices and the Eleven v3 model notes; ElevenLabs, pricing, for the per-character credit costs quoted here.

4.1The models

Three ElevenLabs models are worth weighing, and they trade expressiveness against speed and cost.

For a show, expressiveness is the point, so the natural pattern is to draft and check on Flash — where each pass costs about half as much — and render the final on Eleven v3, the only model that reads audio tags and the only one that does multi-speaker Text to Dialogue. The cost of that expressiveness is that v3 is still an alpha research preview: it is slower, not meant for real-time work, and needs more careful prompting than the others.

4.2The voices, and the order that matters

A voice is an ID you pass with each turn, and you have three ways to get one: pick from the voice library, clone your own (an instant clone from a short sample, or a higher-fidelity professional clone from longer audio — though professional clones are not yet fully optimized for v3, so for v3 features an instant clone or a designed voice is the safer choice today), or design a voice from a text description and keep it. ElevenLabs is clear about the order of importance: voice selection matters most, then the model, then the settings. Casting is the lever; spend your attention there. And casting is exactly where you beat the vendor box — choosing a different pair of voices per episode is the single move that keeps the feed from settling into one sound.

4.3Settings and audio tags

Once a voice is cast, a few settings shape its delivery. On v3 the stability control is the important one: a Creative or Natural setting gives the expressive, tag-responsive performance a show wants, while Robust trades that away for consistency; lower stability is livelier but more variable, so generate a few takes and keep the best. On the standard models, a common starting point is stability around fifty and similarity around seventy-five with style left at zero, adjusted from there. Audio tags are the writer's stage directions made audible — bracketed instructions like [laughs], [whispers], [curious], or even an accent shift, placed inline, which v3 reads as delivery rather than speaking aloud. Because they live in the script text, the writer in Chapter 3 is the one who places them, which is why the two stages were split.

Synthesis and stitching

Reading ElevenLabs, Create speech and Text to Speech on stitching and chunking; troubleshooting on long-generation quality; Text to Dialogue.

5.1Per-clip synthesis is the long-form workhorse

A thirty- to forty-five-minute episode is not made in one call. The durable pattern is to synthesize each turn as its own clip with the Text to Speech endpoint and concatenate the clips yourself — ffmpeg or pydub on your own machine, easily wrapped in a script or driven from a coding agent. The reason to prefer per-clip over one big request is partly quality and partly control: ElevenLabs' own troubleshooting guidance notes that audio degrades on extended conversions and recommends breaking text into sections under about 800 characters, and longer single generations are more prone to mispronunciation and to drifting accent or pacing. Per-clip also means a bad take is one clip to regenerate, not the whole episode.

from elevenlabs.client import ElevenLabs

from pydub import AudioSegment

eleven = ElevenLabs()                          # reads ELEVENLABS_API_KEY
VOICES = {"maya": "<voice_id_a>", "dev": "<voice_id_b>"}

clips = []
for i, t in enumerate(turns):                  # one clip per turn
    audio = eleven.text_to_speech.convert(
        voice_id=VOICES[t["speaker"]],
        text=t["text"],                        # keep each under ~800 chars
        model_id="eleven_v3",
        output_format="mp3_44100_128",
    )
    path = f"clip_{i:03d}.mp3"
    with open(path, "wb") as f:
        for chunk in audio:
            f.write(chunk)
    clips.append(path)

episode = sum((AudioSegment.from_mp3(c) for c in clips), AudioSegment.empty())
episode.export("episode.mp3", format="mp3")

To keep the prosody from lurching where clips meet, use request stitching: pass the surrounding requests' IDs (up to three on each side) via the convert endpoint's previous and next request parameters, so each clip is generated knowing what came before and after.

5.2The short-form shortcut

For a short piece — a five-minute segment, a trailer — Text to Dialogue is the elegant option. It is exclusive to Eleven v3, takes an array of voice-and-text turns, and returns one cohesive file with the hosts' timing and turn-taking matched in a single pass:

audio = eleven.text_to_dialogue.convert(
  inputs=[{"text": t["text"], "voice_id": VOICES[t["speaker"]]} for t in turns],
)                                              # v3 only · ≤ 10 voices · ≤ 2,000 chars

It is lovely, but it caps at about two thousand characters and ten distinct voices per request, so a full episode overflows it and you are back to chunking and stitching anyway. Use it for shorts; reach for the per-clip loop for anything long.

5.3Assembly

Once the clips are joined, the rest is ordinary editing and entirely yours: an intro and outro, a music bed under the open, level normalization, trimming the dead air. None of it is gated by the tool that made the voices, because at this point the voices are just files on your disk.

Stand on the open package, verify, own it

Reading Podcastfy (open-source); ElevenLabs, pricing and the Text to Speech FAQ on ownership and regeneration.

6.1You do not have to hand-roll it

Everything in this guide has been assembled from parts on purpose, so you understand each stage. But you do not have to wire it from scratch: the pattern already exists as open source. Podcastfy is an Apache-2.0 Python package that bills itself plainly as an open-source alternative to NotebookLM's podcast feature. It generates a multi-host conversational transcript from your sources using any of a hundred-plus LLMs — Claude among them — and voices it through text-to-speech backends including ElevenLabs, stitching with ffmpeg, with the customization the vendor box withholds: conversation format and style, specific voices, length from a couple of minutes to half an hour and beyond, multiple languages, and the option to run a local model for the transcript when privacy matters. It installs from PyPI and runs on your own machine.

The choice between standing on the package and hand-rolling is a real one. The package is batteries-included and self-hostable — the fastest way to own a working pipeline. Hand-rolling, as in the chapters above, is what you reach for when the persona work, the per-episode casting, and the exact stitching are the whole point and you want them in your own hands. Both land in the same place the vendor box never lets you reach: a pipeline you own and can change.

6.2The listen-through

No metric replaces playing the whole thing and listening. Synthetic voices mispronounce odd names, occasionally glitch, and sometimes read a tag in a way you did not intend; over a long episode a voice can drift in accent or pace. Put something in the loop that can say no — at minimum your own ears on a full pass, and better, a transcript of the rendered audio diffed against the script you wrote, so a dropped or mangled line shows up as a difference instead of a surprise on air.

6.3The bill

Voice generation is metered in credits, and credits map to characters: about one credit per character on the standard model, roughly half on Flash, and near a thousand credits for a minute of speech. The arithmetic is small per minute but real per episode — a forty-minute show runs on the order of forty thousand characters, which is a meaningful slice of a monthly allowance, and the regenerations that keep it clean add to it. This is why chunking is not only a quality habit but a cost one: a bad take you catch as an 800-character clip is cheap to redo, while a bad take in a single long generation is not. One rule is about rights rather than volume — you own the audio you generate, but commercial use requires a paid plan, and the free tier bars monetized use and attaches an attribution requirement. The paid entry tier is inexpensive, and it is the line where the show becomes yours to release.

6.4What you own

Run the inventory at the end and the case makes itself. You own the cast — personas you wrote and voices you chose, cloned, or designed, varied episode to episode. You own the script, as a file under version control. You own the structure and the length, because they are whatever you authored. You own the edit, down to a single regenerated clip. And you own the audio file itself, produced on your own keys and stored where you choose. That is the equity-and-sovereignty argument in miniature: own the means of making the show, rather than renting the show and the wall around it. The pipeline is portable too — swap the writer or the voice service for another and the other half still stands, which is a freedom no single vendor's box will give you.