The first AI tool to make me truly think it was beyond a gimmick was NotebookLM. I’ve been using it since its early Google Labs days, and the reason why it attracted me from day one was because it didn’t try to be everything. It did one thing, which was build a personalized AI that was only familiar with what you fed it. Then came Audio Overviews, and the grounding I loved got wrapped in something fun: two hosts walking through all my sources like they’d read them.

As someone who has always been a podcast person and doesn’t spend a minute without her AirPods plugged in, it felt like the feature had been handmade for me. The feature has been around since September 2024, and between then and today, I’ve used it extensively while also testing competitors who claim to do something similar. Most were forgettable, and I kept coming back to NotebookLM. This continued until the day I generated a single podcast episode using Claude’s Opus 4.8 model, and it quietly embarrassed every NotebookLM Audio Overview I’d generated.

NotebookLM’s podcasts begin to sound the same after a while

They’re great, until you’ve heard enough of them

Like I mentioned above, I’ve been a loyal NotebookLM Audio Overview fan since the day Google added it to the tool. I used the feature daily when all you could do was upload documents and hit the button to generate an Audio Overview, when you had zero say over what came out. You fed it sources, you got two hosts and a fixed-length conversation, and that was the deal. As time passed, you got more control — the ability to jump into the conversation and ask the hosts questions yourself, length options to make episodes shorter or longer, a custom prompt to steer what the hosts focused on, and even different formats you could pick (Brief, Debate, Critique).

So, I’ve generated Audio Overviews throughout these stages, and for the most part, I love them. But when you listen to these podcasts as much as I have, you’ll slowly begin to see the cracks. You’ll begin to notice patterns in how every podcast is structured, in how one host responds to the other, in the little verbal tics that show up no matter what you’ve fed it. You’ll notice the same “wow, that’s fascinating” handoffs. The same mid-episode pivot where one host suddenly goes “okay, but here’s what really stood out to me.” Every source, no matter how dry or depressing it might be, gets the same enthusiasm. Every point a host makes is viewed as a great point by the other.

I’ve generated podcasts on everything from lecture slides to research papers to my own articles, and if you listen to them closely enough, you’ll notice all of them sound the exact same way. They’re structured in a very similar pattern, opening with a warm “so, let’s get into it,” circling through the main points with the same call-and-response rhythm, and wrapping up with a tidy “what a fascinating topic” send-off.

Unfortunately, this is something a setting couldn’t really fix. I narrowed down the issue to the underlying model being used to produce the script. And every LLM has its own “personality.” It writes a specific way, uses certain phrasings, gravitates toward certain rhythms, and so on. Given NotebookLM is a Google product, it uses Gemini models, and right now, it’s being powered by Gemini 3.5. So, the solution here to break the monotony that was bothering me was clearly to change the model writing the script. And of course, NotebookLM gives you no such option. That’s where Open Notebook comes in.

Open Notebook is an open-source, self-hosted NotebookLM alternative

It lets you pick the brain

Open Notebook is an open-source, self-hosted alternative to NotebookLM. It’s built by a developer named Luis Novo (lfnovo on GitHub), and released under the MIT license. For those unfamiliar with what self-hosting means, it basically means that the whole thing runs on your own machine, unlike NotebookLM, which runs on Google’s servers. You spin Open Notebook up locally using Docker, which can admittedly be a pain to set up.

I like to consider myself good with tech, and I struggled to set Docker and Open Notebook up for the first time! Feature-wise, Open Notebook is built with the same philosophy that made NotebookLM click for me. You can upload documents, and it grounds everything in what you’ve fed it, including PDFs, links, text files, YouTube videos, even PowerPoint slides. It can summarize your sources, generate insights from them, and yes, turn them into podcast episodes too.

Beyond running on your own device and being better for privacy, the real reason Open Notebook caught my attention is that it lets you choose the models powering every stage of the process. You pick the language model that writes the script, the embedding model that processes your sources, and the text-to-speech model that voices the episode. NotebookLM gives you Gemini and that’s it. Whereas with Open Notebook, you can provide it any API key (Anthropic, OpenAI, Google, xAI, and more) and pick from whatever models that provider offers. You can even use a local LLM if you have the hardware to run one, meaning your data never has to leave your machine at all.

For the experiment, I decided to use the model that has been praised for its creativity, storytelling, and writing most: Anthropic’s Claude. For best results, I used the most recent Opus model, Opus 4.8. Given this model doesn’t have its own embedding or text-to-speech capabilities, I paired it with OpenAI’s text-embedding-3-small for processing the source material and OpenAI’s tts-1 for generating the voices. So the final setup was Claude doing the thinking and writing, and OpenAI handling the technical plumbing around it. After the Docker setup is done, all you really need to do is grab the API keys, and plug them into Open Notebook. I then created a notebook within the tool, and uploaded a doctoral dissertation (80-page PDF on Generation Z’s attitudes toward mental health services).

Generating the podcast and what it cost

The process, the result, and everything in between

Before you can generate a podcast, you’ll need to set up your episode and speaker profiles. This is where you configure things like how many hosts the episode should have, what tone they should use, and which models handle the outline, the script, and the voice. As you can probably tell, this means you have control over every aspect of the podcast you’re about to generate! Once I had the profiles properly configured, I hit generate.

Open Notebook’s process works in stages: Opus first drafted a four-segment outline of the episode, then expanded each segment into a full script, producing 31 lines of dialogue in total. Once the script was done, OpenAI’s tts-1 took over and rendered each line into audio, stitching them together into a single episode. The whole thing took about 18 minutes from the moment I hit generate to a finished, playable 20-minute episode. So, you’re essentially waiting as long as the thing you get to listen to. Most of that wait wasn’t Claude thinking, either. The script itself was done in about two minutes. The remaining 16 minutes were the audio rendering, which Open Notebook processes in sequential batches rather than all at once.

The podcast Open Notebook generated was incredible. It was far more detailed than any podcast I’ve generated using NotebookLM, didn’t feel predictable, and most importantly, it didn’t sound like every other AI podcast I’d heard before. The host (I chose the solo expert format for this run, so it was a single presenter rather than NotebookLM’s signature two-host setup) actually engaged with the material the way you’d want a real subject-matter expert to.

She didn’t rush past the complicated findings to get to a tidy conclusion, and given I had used a custom prompt for it, it was shaped exactly to my requirements. While I used a single host for my run, I could have added as many hosts as I wanted — Open Notebook lets you create multiple speaker profiles, each with their own name, personality, and even a different TTS voice, so building a two-host or even three-host conversation is just a matter of adding profiles and assigning them to the episode.

Given that my complaint with NotebookLM was never how the hosts sounded vocally (to the contrary, I’ve always praised Google for how natural the voices are), the model drafting the script is what makes or breaks the podcast produced. The model writing the words is what determines whether an episode feels thoughtful or formulaic, and that’s exactly the part swapping to Opus changed.

As for the cost, since you’re using your own API keys, every generation has a price tag, unlike NotebookLM. My run cost $0.68 in Anthropic credits for the Opus script and $0.14 in OpenAI credits for the TTS audio, coming out to about $0.82 total for a single 20-minute episode. Not expensive, but not free either. NotebookLM’s free tier lets you generate 3 Audio Overviews daily, and the only way to generate a fully free episode with Open Notebook would be to run a local model for the script and a local TTS for the audio.

A dollar and a Docker install between you and better podcasts

That said, I don’t think Open Notebook is for everyone. Between the Docker setup, the API keys, the model configuration, and the profile wrangling, Open Notebook asks a lot more of you than NotebookLM ever does. If you’re happy with how NotebookLM sounds, there’s no reason to bother. But if you’ve listened to enough episodes to hear the pattern, and it’s started to bug you the way it bugged me, the $0.82 and the evening of setup are worth it.