One Prompt, One Paper, One Podcast.

Signup Write New Story One Prompt, One Paper, One Podcast. by Durganshu Mishra by Durganshu Mishra | @ durganshu Computational Sciences@TU Munich.

I had a paper open on my phone that I was never going to finish.Not because it was bad — because it was a methods paper, and methods papers are written to be verified, not understood: pipeline diagrams, precision-recall tables, sentences like “spine-based blur sizing.” I was on a train platform with a few minutes to spare and roughly that much appetite. What I actually wanted was for someone to explain it to me. Two people, ideally, talking it through — one of them asking the questions I’d have asked.

Turning a document into that kind of audio normally means a detour: open a different tool, sign in, export the PDF, hand it over, wait, download the result, then find somewhere sensible to put it. Nothing about that is hard. It’s just enough steps that I don’t do it for the paper I’m mildly curious about — which is most of them.

So I tried it with Gotcha, world’s first AI co-pilot for Android, instead, on the phone I was already holding. Twice — once with a link, once with the PDF itself.

I pasted the URL into Gotcha and typed one sentence:

This research paper feels a bit difficult to understand: https://www.nature.com/articles/s41598-026-50340-5. Can you create a podcast out of it to help me explain?

That’s the entire prompt. No format instructions, no host names, no outline, no length.

Your paper looks like a tough read — I’ll turn it into a podcast that walks you through it.

Then it went and got the paper itself — one webfetch call — and came back having actually read it:

That SecurePose paper is dense — I’ll turn it into an easy listening podcast explainer for you.

Note what happened in that sentence. I never told it what the paper was called. I gave it a URL ending in s41598-026-50340-5.

One more tool call, synthesize_podcast_dialogue, and:

Your podcast is ready! 🎙️ SecurePose Explained — 6min 46s dialogue Saved to: Gotcha/Podcasts/securepose-paper-explained.m4a (6.4 MB) — you can find it in your Files app under Gotcha/Podcasts

Then it told me what was in the episode:

And it finished with: “Want me to play it or share it to another app?”

Elapsed: about the time it takes to read this section. Apps opened: one. Files moved by hand: none.

A public link is the easy case. The case I actually cared about is the one where the document is mine — a manuscript under review, a draft nobody else should have a copy of, a paper behind a login I’m entitled to read and not entitled to redistribute. That’s where “just upload it somewhere” stops being a shrug.

If i give you a pdf of a research paper, can you create a podcast using it

Gotcha’s answer was more useful than I expected, because it volunteered its own constraints without being asked:

Yes, absolutely — that’s one of my best features.

It laid out the two modes — synthesize_podcast for clean single-narrator narration, synthesize_podcast_dialogue for a conversation between two distinct voices "with natural pauses and back-and-forth" — noted that dialogue is "much more engaging for research papers," and then listed the fine print:

I attached the PDF — s41598-026-50340-5.pdf, 1.9 MB — and wrote two words: try this.

Your SecurePose paper is in — I’ll turn it into a podcast for you.

A list_files call, then synthesize_podcast_dialogue, then:

Done! 🎙️ Your SecurePose paper is now a podcast: SecurePose — Automated Face Blurring and Kinematics Podcast 10:36 · two-host dialogue · 10 MB Saved to Gotcha/Podcasts/ — visible in your Files app

Two words of input. A ten-minute explainer of my own document, sitting in my Files app, having gone nowhere.

Both runs were the same request to the same tool. The only thing that changed was how much of the paper I handed over: a URL one time, the full PDF the next. That alone decided how deep the episode went.

Here’s what each version said about the same three things.

That’s the difference between 6 minutes 46 seconds and 10 minutes 36 seconds. The extra four minutes aren’t a slower read of the same material — they’re things the short version never mentioned, and they’re exactly the things that live in a paper’s tables and figures rather than its summary. A fetched web page gives Gotcha whatever that page renders. The PDF gives it the whole document.

Which makes the depth control refreshingly dumb: it’s not a setting, a slider, or a prompt you have to phrase correctly. Want the gist? Send the link. Want the paper? Send the PDF. The sentence you type is the same either way.

The two-host format matters more than it sounds. A single narrator reading a summary is a summary. Two hosts can do the thing that makes explanation work: one of them can be confused. One says “average precision 0.948 across 116 videos” and the other gets to ask whether that’s actually good — which is exactly the question you had.

Single-narrator mode is there whenever you’d rather have it. synthesize_podcast produces clean, lecture-style narration from the same input — shorter for the same material, since nobody is asking questions — and it's the better pick when you already know the subject and want the content rather than the explanation, or when you're generating a stack of short episodes and want them uniform. Gotcha offers the swap unprompted; at the end of the PDF run it asked whether I wanted "a shorter 5-min single-voice version as well." You can also just say which one you want in the original sentence. I picked dialogue both times because I was the one who didn't understand the paper.

Under the hood, synthesize_podcast_dialogue writes the script with a distinct voice per host — set in Settings → Speech — and picks the pause after each line while it writes, so a quick interjection runs into the next line and a genuine surprise gets a beat before the reply. Long scripts are synthesized in segments and joined on the device. The result lands as an.m4a under Gotcha/Podcasts (or.mp3 when Termux's ffmpeg is around), and share_podcast drops it into Android's share sheet. Ask for it in your Downloads folder and Gotcha will just run the shell command and move it — that isn't a podcast feature, it's an agent with a shell.

The two runs above both started from a paper, because that’s the problem I had. But the input is optional.

Ask Gotcha for a podcast about a topic and it will write and voice one. “Explain how mRNA vaccines work, two hosts, ten minutes.” “Make me a 5-minute episode on the causes of the 2008 financial crisis.” “Turn my revision notes into a conversation I can listen to.” A topic, an article, a voice memo, your own notes, or nothing but a sentence — they’re all the same kind of request.

-Anyone on-boarding into a new field, converting the dense internal doc nobody has time to read into twelve minutes of two people explaining it.

— - A student turning a week of lecture slides into something to listen to on the bus.

The cost of producing one of these used to be high enough that you only did it for material worth publishing. At one sentence per episode, you can make them for an audience of one.

It’s the comparison everyone will make, so let me make it first — and fairly. NotebookLM is very good at this. Its Audio Overviews were the thing that convinced most of us that a synthetic two-host conversation could be genuinely pleasant to listen to, and if you’re building a research workspace out of forty sources with citations threaded through it, that’s what it’s for and it’s excellent at it.

The difference isn’t quality. It’s shape.

NotebookLM is a destination: you go to it, sign in, bring your sources to it, and it hands you a result you then bring back. That’s a perfectly good trade when the material is worth the round trip — a real project, a body of sources you’ll return to.

Gotcha is already where the material is. The paper was on my phone; so was the assistant; so was the output. There was nowhere to go, nothing to sign into, and nothing to bring back — the episode landed in my Files app, two taps from where I was standing. That’s the difference between “worth the round trip” and “worth one sentence,” and it changes what you make. I now make these for papers I’m only mildly curious about, which was never going to be NotebookLM’s category — not because it’s worse, but because it costs more attention than mild curiosity has to spend.

Use both. I do. One of them I use for projects; the other I use on a Tuesday.

Worth being precise here, because this is the part most tools are vague about — and to Gotcha’s credit, it was precise before I was.

Nothing of mine was uploaded. There was no drop box, no account, no third party holding a copy of my file, no document sitting in someone’s storage bucket waiting to become a training example. In run one Gotcha fetched a public URL — the same one your browser would fetch. In run two the PDF sat on the phone, the text was extracted on the phone, and the audio was assembled on the phone.

What does leave the device depends on how you configure Gotcha:

The reasoning and the script. Point Gotcha at a local model through Ollama, llama.cpp, or LM Studio and the paper’s text is processed on the phone. Point it at a cloud endpoint and the text goes to the endpoint you chose — your key, your provider, your call.

The voices. This one has no local option today, and Gotcha says so unprompted: Android’s built-in text-to-speech can’t write audio files, so podcast generation needs Samosa AI or another external speech API set in Settings → Speech. The script text goes to that endpoint to be spoken.

So the honest version: no file upload, no new account, and a local-model path where the document itself never moves off the phone. Audio assembly always happens locally. You can check every part of that, because Gotcha is 100% open source under the AGPLv3 — the claim is auditable rather than promised.

That matters most for exactly the material worth making a podcast out of: unpublished manuscripts, internal documents, patient-facing material, a student’s own coursework. The privacy question isn’t hypothetical for those, and the answer here is structural — the file doesn’t move, so there’s nothing to trust anyone with.

There’s an irony I enjoyed, given the paper. SecurePose exists because researchers can’t share patient gait videos without stripping identity out of them first, and the authors’ central design choice was to do the sensitive processing locally, in the clinic, rather than shipping raw patient video somewhere else. I got that paper explained to me by a tool that made the same call about my data.

Turning a document into a listenable conversation used to be a small project. Get the file, take it somewhere, wait, retrieve the result, put it where you’ll find it.

What replaced it: paste a link, or attach the PDF and type try this.

That’s what keeps surprising me about running an agent on the phone instead of in a browser tab. The tool call is the smaller half. The larger half is that the network is already there, the file is already there, the Files app is already there, the share sheet is already there — so the work doesn’t need a pipeline. It needs a sentence.

Gotcha is the world’s first AI co-pilot for Android — 111+ tools and growing, Monitor mode for read-only inspection and Operator mode for execution, Screen Lens, push-to-talk through the Assistive Ball, the “Hey Gotcha” wake word, and Termux shell access. It runs on Android 11+ (API 30+), works with local or cloud models, and is open source under the GNU AGPLv3.

I listened to the long one on the train. I now know more about SecurePose than I would have from the twenty minutes I’d actually have given the PDF.

Android's Missing MP3 Encoder: The Problem and Four Workarounds