yt2textbook: what one agentic model ships when the brief is a real open-source release.
Summarizers compress a video into a paragraph and lose the reason the video existed. We set the harder bar: a document that replaces the watching, screenshots, comprehension checks, glossary, and Word export included, and asked one agentic model to ship it as a real open-source release before lunch. This report records the morning: what the model carried alone, the four corrections that came from people, and the hygiene gates that made the result publishable.
The Finding
Lead with the answerOne model can ship the whole release, and the seams are exactly where product judgment lives. In a single recorded morning, Kimi K3 took yt2textbook from an opening brief to a packaged open-source repository: a working pipeline about 40 minutes in, and a complete release about 4.5 hours later, with an 11-document example corpus holding 258 embedded screenshots, Word exports for every document, a license and notices layer, three README diagrams, a recorded terminal demo, and search-optimized repository metadata. The tool does what summarizers do not: it prints a document that replaces the watching, with every screenshot vision-filtered, captioned, and linked to its second in the source video. The model wrote every line of code. The four material corrections in the record were all judgment, not syntax: the writer model kept emitting em dashes until a deterministic guard replaced the prompting, one course module shipped thin after the planner answered prose instead of JSON and was caught on output review, the product name and README structure were rejected and rebuilt to the owner's direction, and the rights and privacy review before publication stayed human. Speed and structure came from the model. The discipline that made it publishable came from us.
The question
Can one agentic model carry an open-source tool from idea to published repository, example corpus included, in a single morning, and where does it still need people?
The subject
Kimi K3 in an agent runtime with file and shell tools, directed in supervised sessions with a human review gate on every output.
Not a claim about
Model rankings, transcript accuracy at scale, or unattended autonomy. One tool, one morning, one recorded window.
Who It Is For
And what they print with itTeams running onboarding
Point it at the internal walkthrough playlist and hand new hires documents they can search, annotate, and skim, instead of a folder of hour-long recordings nobody rewatches.
Knowledge base and second-brain owners
Print straight into an Obsidian vault, Notion, a team wiki, or a Git repo. Output is plain Markdown with relative image links and timestamps intact, so it behaves like every other note you own.
Engineers following a technical tutorial
Get the commands as copyable code blocks and the settings screens as captioned screenshots, so you can work from the page instead of scrubbing back through the video for the one line you missed.
People building with LLMs
Every run writes the textbook, the timestamped transcript, and provenance metadata: a clean, structured unit of context to retrieve over or use as training material.
Readers who cannot or would rather not watch
For people who take in text faster than speech, or who cannot play video at work, a printed document turns a 5 hour course into something you can read at your own pace.
Anyone archiving a course
A video that might be deleted, paywalled, or reorganized becomes a document you hold, with the visuals preserved and every claim linked back to its second in the source.
Run It Yourself
Install · key · printFive steps, about three minutes on a machine that already has Python. The tool runs on your own OpenRouter key and ships with none: with the default models, printing a 40 minute tutorial costs on the order of a few US cents, and your provider dashboard shows the exact spend.
- 01
Install the requirements
Python 3.10 or newer, the uv runner, and ffmpeg for frame sampling. Pandoc is optional and only used as a fallback for Word export, since python-docx is the default engine and installs with the requirements.
# macOS brew install uv ffmpeg # Linux curl -LsSf https://astral.sh/uv/install.sh | sh sudo apt install ffmpeg - 02
Get the code
Clone the repository. There is no install step and no package to publish: the tool is a single Python module, and the first run resolves its dependencies automatically.
git clone https://github.com/zorost/yt2textbook.git cd yt2textbook - 03
Add your own model key
Create a key at openrouter.ai, add a few dollars of credit, and drop it into a local .env, which is already gitignored. The tool never ships with keys and never sees yours beyond your machine.
cp .env.example .env # open .env and replace the placeholder with your key - 04
Print a video or a whole playlist
Pass any YouTube URL. Add --docx for a styled Word textbook alongside the Markdown, and use --limit N to trial the first few videos of a long playlist before committing to all of it.
uv run yt2textbook.py "https://www.youtube.com/watch?v=VIDEO_ID" --docx uv run yt2textbook.py "https://www.youtube.com/playlist?list=LIST_ID" --limit 3 - 05
Read your textbook
Output lands in textbooks/<video-title>/: the document as README.md, the styled .docx if you asked for one, the embedded screenshots, the timestamped transcript, and a meta.json recording which models ran. Open it in Obsidian, VS Code, GitHub, or Word. Every screenshot caption links back to that exact moment on YouTube.
Under Test
Stack and environmentThe Account
How it was built and what happenedA real release, not a demo.
The brief was deliberately commercial-grade: take any YouTube video or playlist and print it as a complete, illustrated textbook, the kind of document that replaces watching rather than summarizing it. Screenshots where the video shows something, learning objectives up front, comprehension checks and a glossary at the back, timestamped links to every source second, and a Word export. Then package the tool as an open-source release a stranger can run: README, examples, license, notices, and repository metadata that search engines can find.
Summarizer apps were deliberately not the bar. A paragraph about a 52-minute setup guide is useless when you actually have to set the thing up. The hard bar is a document you can work from, and that is what made the build worth measuring: the model had to carry ingestion, vision filtering, course planning, prose, and packaging, not just text in, text out.
The autonomy budget, measured in minutes.
The opening brief was sent at 7:53 in the morning. About 40 minutes later the pipeline ran end to end: transcript fetched, frames extracted and filtered, a course plan written, sections printed, and the first validated document on disk. By mid-morning the full example corpus existed, eleven documents from the Hermes Atlas training channel processed in parallel batches, with one module re-printed after the planner fix described below. By early afternoon the release was packaged: README restructured to the owner's direction, three diagrams drawn, a terminal demo recorded, license and notices written, repository created and described for search.
The human contribution was briefs, review gates, and four judgment calls. This is the working pattern the experiment set out to probe: a model left alone with a folder, a toolchain, and a definition of done, inside a loop where a person reviews every output before it ships.
- Working pipeline about 40 minutes after the opening brief
- Full packaged release about 4.5 hours later, corpus and marketing layer included
- A human review gate on every output
A pipeline, a corpus, and a package.
The measured output is about 1,050 lines of stdlib-first Python in a single module: transcript ingestion with a local Whisper fallback, frame extraction by scene-change detection plus interval sampling, perceptual-hash deduplication, a vision filter that caps classification at 24 informative frames per video, a course planner with a retry-and-fallback guard, section writers, and an assembly pass that adds comprehension checks, a glossary, and footnotes. The Word engine renders each document as a styled textbook with a cover page, a table of contents, real tables, and captioned figures. A deterministic normalization pass enforces the house style on every generated document, because the writer model would not.
The evidence pack is the corpus: eleven printed course documents from the Hermes Atlas training channel, reproduced with the owner's permission, holding 258 embedded screenshots, each captioned and linked to its second in the source video, plus eleven Word exports. The package around it is the release layer: README with three diagrams and a recorded terminal demo, Apache-2.0 with NOTICE, brand and security policies, third-party provenance notes, and repository metadata written for search.
The gaps were product judgment, not syntax.
Four material corrections were logged in the window, and none of them were code. First, the writer model kept emitting em and en dashes despite explicit prompt instruction; prompting did not hold, so a deterministic normalization pass in code did. Second, one masterclass module printed thin, about a third the depth of its peers, because the course planner answered prose instead of structured JSON; output review caught it, a retry-and-fallback guard went in, and the module was re-printed. Third, the product identity was a human call: the model's first name was not discoverable, and its first README buried the usage path, so the owner rejected both and the model rebuilt them to direction, name, structure, and search positioning included. Fourth, rights and privacy stayed human: choosing owner-permissioned source material, writing the provenance notes, and running the secrets review before publication.
Every one of those corrections is a judgment about context the model did not hold: what a name is worth, what a stranger needs first, what may legally enter a public repository. That boundary, not code volume, is what this experiment was designed to locate.
Printed does not mean proven.
A printed page reads authoritative whether or not it is. The documents are model-generated from real transcripts and real frames, but the prose is not independently fact-checked, frame OCR can misread a blurry terminal, and videos without captions fall back to local transcription at higher cost. The corpus is also one channel's content: English, terminal-heavy, single-instructor. Slideshow talks, panels, and non-English sources are untested. The tool and this report both name that boundary, because treating a legible document as an authoritative one is exactly the mistake this program exists to avoid.
From the Field
Captured from the live build



What Held, What We Flag
Wins and limits, side by side- The pipeline shipped and held across the corpus: 11 complete documents from 12 runs, with exactly one structural failure, caught and re-printed.
- Every document carries its evidence: 258 screenshots embedded across the corpus, each vision-filtered, captioned, and linked to its second in the source video.
- The package shipped whole: README with three diagrams and a recorded terminal demo, 11 Word exports, license and notices, provenance notes, and search-ready repository metadata.
- Hygiene gates held: zero em or en dashes across the published corpus after the deterministic normalizer, zero secrets in the tree at publication.
- The autonomy is real: working tool about 40 minutes in, full release about 4.5 hours in.
- The document prose is model-generated and not independently fact-checked; a printed page reads authoritative whether or not it is.
- Frame OCR and vision classification depend on the chosen models and on video legibility; no accuracy benchmark was run.
- Transcript availability caps the tool: no captions means a local Whisper fallback at higher cost.
- Product judgment stayed human: the name, the README structure, the search positioning, and the rights and privacy review were owner calls.
- One model, one morning, one tool. This is a dated field record, not a ranking and not a general claim about agentic capability.
Measurements
Enforced on every build- Model under test
- Kimi K3, agentic supervised sessions
- Build window
- One morning, August 2026: working tool in about 40 minutes, packaged release in about 4.5 hours
- Code produced
- About 1,050 lines of Python, one stdlib-first module
- Example corpus
- 11 printed course documents from 12 runs
- Embedded screenshots
- 258 across the corpus, each timestamp-linked
- Word exports
- 11 styled .docx textbooks
- Material human corrections
- 4 logged in the window
The model printed the textbooks. The product calls stayed human.
Disclosures
What a careful reader deserves- All tool code and all published example documents were produced by the model under test and entered the repository only through human review gates.
- Example documents derive from the Hermes Atlas training channel, reproduced with the channel owner's permission. Every document credits and links its source video.
- The tool calls third-party APIs with the user's own key. The repository contains no keys, and its documentation states the per-run call structure rather than invented totals.
- The tool downloads and processes third-party video content. Users are responsible for the rights of the content they print, as stated in the repository's usage terms.
- Vendors and models, including the runtime defaults DeepSeek V4 Pro and Gemini 2.5 Flash, are named as components and test subjects only. This is a dated field record, not an endorsement.
- The brand and the code are licensed separately: Apache-2.0 for the code, all rights reserved for Zorost marks, documented in the repository.
Questions, answered
yt2textbook · common questionsHow is this different from a YouTube summary app?
A summary decides what you do not need to know, then throws it away. yt2textbook keeps everything and reorganizes it for reading: full step-by-step procedures, screenshots of the code, terminals, and settings screens, on-screen text reproduced as copyable code blocks, comprehension checks, a glossary, and footnotes. A 200 word summary tells you what a 40 minute tutorial was about. This prints the document you follow to actually do the thing.
What does it cost to run?
You bring your own OpenRouter key and pay the model providers directly. With the default models, printing a 40 minute tutorial costs on the order of a few US cents, and your provider dashboard shows exact per-call spend. The cost levers, in order of impact, are a cheaper writer model, skipping screenshots with --no-frames, halving the vision calls with --max-frames 12, and trialing playlists with --limit.
Do I have to use OpenRouter?
No. The client is a plain OpenAI-compatible chat completions call. Point OPENROUTER_BASE_URL at any compatible endpoint and name the models you want. The document writer and the vision filter are each replaceable with one line of configuration.
What if the video has no captions?
The tool asks for captions first and falls back to local Whisper transcription when none exist, which costs more time and compute. Caption retrieval asks for English first but accepts whatever the video offers, and the writer follows the transcript's language. Whisper transcription is multilingual.
Where does my data go?
Your transcript slices and candidate frames are sent only to the models you configured, under your own account. Nothing else phones anywhere, and temporary files are deleted after each run.
Is it legal to print someone else's video?
The tool processes content you have access to, for your own use. Respect creators and do not republish generated documents from videos you do not hold rights to. The example documents bundled in the repository come from the Hermes Atlas channel with the owner's permission, recorded in the third-party notices.
A video printed as one long thin section instead of a real course. Why?
The course planner occasionally answers prose instead of structured JSON. The tool retries once automatically, and if that still fails you get a safe single-section fallback rather than a crash. Re-running the same command almost always produces the full multi-section document. This exact failure is documented in the field report above, because it is the one structural failure we hit across the example corpus.
Can I trust what the document says?
Treat it as a well-organized reading of the source, not as a verified reference. The prose is model-generated from the real transcript and real frames, and it is not independently fact-checked. Every screenshot links to the second it came from, so the source is always one click away when a claim matters.
Go Deeper
Run it · read it · build on itServing those who
need to stay ahead.
We don't pitch slide decks. We show you what we've already built in your domain, then engineer what your mission requires.
