What it costs

The short post that started this report gave a bill in one table: under $500 of model time per book, $6,000 to $12,000 for the books, about 200 hours of human checking. This chapter rebuilds that bill from its parts, shows the arithmetic, and tests which assumptions matter.

The answer doesn't change much. It gets sharper. Model cost is real but small, a few hundred to about two thousand dollars for a full book depending on which model does what. Buying the books costs several times more than the models. The human hours, mostly checking facts and making the choices Greene says are the job, cost more than both.

Everything here is a model, not a measurement. No one has run this pipeline end to end. Where a number is a vendor price or a published figure, I link it. Where it's my assumption, I say so and show what happens when it moves. The stages are the ones described in the pipeline chapter. The tools behind them are in the tools chapter.

Prices and units#

Anthropic#

All prices are US dollars per million tokens (MTok), from Anthropic's pricing page, read on 2026-11-11.

Four rules from the same page shape the model:

• Batch is half price on both input and output. It's asynchronous, so it suits stages where nobody is waiting.
• Cache hits on Opus 5.5 and Sonnet 5.5 cost 0.05× the base input price. A 5-minute cache write costs 1.25× input and a 1-hour write costs 2×. So caching pays when the same long prefix is read several times in a short window. The page says these discounts stack with batch.
• Opus and Sonnet get the full 1M-token window at standard price. "A 900k-token request is billed at the same per-token rate as a 9k-token request." Haiku 5.5 is the exception: a request whose prompt is over 100,000 tokens pays the higher row for the whole request, cache reads included.
• Thinking costs output. On current models, reasoning is billed as output tokens; the thinking docs point to a usage field that reports "how many of the billed output tokens were internal reasoning." The model below starts with no thinking and adds it in the sensitivity section.

OpenAI and Google#

For comparison I use only the prices recorded in this report's research notes, as listed on the vendor pages on 2026-11-11 (OpenAI, Google AI Studio). I didn't model their caching or batch terms.

Tokens per word#

The research notes give about 1.3 tokens per English word, with a range of 1.07 to 1.35 by type of text (source). That figure was measured with an OpenAI tokenizer. Anthropic's pricing page says Claude 4.7 and later models use a newer tokenizer that "produces approximately 30% more tokens for the same text" than earlier Claude models. That's a comparison between Claude tokenizers, not with OpenAI's, so I can't convert it precisely. I use 1.3 as the base and 1.7 (1.3 × 1.3) as a pessimistic case. Anyone running this for real should count tokens on a sample of their own books first.

At 1.3 tokens per word:

The finished-book length is my assumption, picked to sit near Greene's recent books. The Laws of Human Nature is 624 pages and The Law of the Sublime 496, per Penguin Random House. Greene calls the Sublime "450 pages" in one interview. 150,000 words is in that range; the sensitivity section tries 100,000 and 200,000.

Part A: one Greene-scale book#

The assumptions#

Greene says he reads 300 to 400 books per project. He gave that range to Joe Rogan in 2014, and in the same answer said each book goes onto "maybe 10, 20, 30 cards" and that he ends with 2,000 to 3,000 cards. A secondhand recap of a 2015 interview gives 200 to 300 books. I model 300, 400 and 500, with 400 as the base.

Note that 400 books × 25 cards is 10,000 cards, four or five times Greene's real box. A model doesn't get tired, so the pipeline over-produces and lets the second pass and the architect cut. If you'd rather match Greene's box, the sensitivity table includes 10 cards per book.

Stage by stage#

Each stage below gives the token arithmetic. "Prompt" is the size of the largest single request, which matters for Haiku's price tier.

1. Scout. For each of 600 candidate books, read a catalogue record, contents and reviews (about 5,000 tokens) and write a short reason to keep or drop (500 tokens). 600 × 5,000 = 3.0M input. 600 × 500 = 0.3M output.

2. Acquire. No model. Costed in Part B.

3. Margin pass. Read every book in full and mark passages, verbatim, with page numbers and tags. To stay under Haiku's 100,000-token threshold, each book goes in two halves of 65,000 tokens plus 3,000 tokens of instructions each. Input per book: 130,000 + 6,000 = 136,000. Output: 10,000 tokens of marks (about 50 passages with page and tag). For 400 books: 54.4M input, 4.0M output.

4. Second pass. Greene's two-month wait is replaced by a fresh context. The model re-reads the whole book alongside the marks, the current theme map and instructions: 130,000 + 10,000 + 5,000 + 3,000 = 148,000 tokens, again in two halves. It outputs 3,000 tokens of keep or drop decisions. For 400 books: 59.2M input, 1.2M output.

5. Carder. For each book, read the surviving marks with their page context (20,000 tokens plus 3,000 of instructions) and write 25 cards of 200 tokens. Input 400 × 23,000 = 9.2M. Output 400 × 5,000 = 2.0M.

6. Architect. 10,000 cards at 200 tokens is 2M tokens, which doesn't fit one 1M window. So the architect works from an index of each card's title, theme and source, about 40 tokens a card: 10,000 × 40 = 400,000 tokens. Ten passes over that index (plus 5,000 tokens of instructions) to propose, cut and merge themes into chapters, with 20,000 tokens of output each. Input 10 × 405,000 = 4.05M. Output 0.2M.

7. Story hunter. For each of 15 chapters, read the chapter's cards (10,000 ÷ 15 = 667 cards × 200 = 133,000 tokens) plus four extra biographies (4 × 130,000 = 520,000) and write 15,000 tokens of ranked candidate stories. That's 653,000 tokens per request, inside Opus's 1M window. Input 15 × 653,000 = 9.8M. Output 0.23M.

8 and 9. Drafts and critics. This is the expensive stage, so here it is in full. For each chapter, each draft runs five calls that share one long prefix:

Once per draft, a repetition critic reads the whole book (195,000 tokens) and writes 5,000 tokens.

Per draft: input 15 × 5 × 181,333 + 195,000 = 13.8M. Output 15 × 35,000 + 5,000 = 0.53M. Over 20 drafts: 275.9M input, 10.6M output.

The short post priced a draft as its output alone, about $4 on Opus for a 195,000-token book. That's still right for the words written. What it left out is that every rewrite re-reads its cards, and that the critics read too. Input is where the money goes.

Totals by stage#

Priced per model#

First, every stage on one model, three ways: list price, everything on the batch API, and list price with caching where a prefix is reused (the architect's index and the drafts' chapter prefix, using the 5-minute cache write). On Haiku, the architect, story hunter and drafts all have prompts over 100,000 tokens, so they pay the higher tier.

To check one cell: the Opus margin pass is 54.4M × $4 + 4.0M × $20 = $217.60 + $80.00 = $297.60.

The cached drafts on Opus work like this. There are 20 drafts × 15 chapters = 300 groups of five calls. Each group writes its 181,333-token prefix once at $5 and reads it four times at $0.20:

Against $1,315.60 uncached. The cache saves 59% on this stage, and it only works if the five calls in a group run within five minutes of each other. Spread them out and you need the 1-hour write at $8, which still pays because there are four reads. Run them days apart, as a human-paced process would, and the cache expires between drafts. The "cached" column assumes the critics and reviser run straight after the drafter.

Batch and cache don't combine cleanly here. The pricing page says the discounts stack, but a batch job runs asynchronously, so a five-call sequence that depends on each call's output is awkward to batch. I treat the draft loop as interactive.

A realistic mix#

Nobody would run every stage on one model. The pipeline chapter puts cheap models on the bulk reading and Opus on judgment. Priced that way:

Four-fifths of that is the draft loop. The whole reading side, 400 books read twice and turned into 10,000 cards, is $92.62.

If the margin pass sends each book to Haiku in one piece instead of two halves, every request is over 100,000 tokens and pays the higher tier: 54.4M × $0.50 + 4.0M × $2.50 = $37.20 at list price instead of $7.44. Chunking is worth doing.

300, 400 and 500 books#

Each extra 100 books adds about $365 on all-Opus and about $82 on the mix. The number of books grows the reading stages. It also grows the card pile, which every draft re-reads, so it shows up in the draft loop too.

Other vendors, same token counts#

The same 415.6M input and 18.5M output tokens at list price, no caching or batch, using the prices above:

These ignore context limits. I don't have verified window sizes for most of the non-Anthropic models, and a 653,000-token story-hunter prompt won't fit everywhere. Treat the column as a price comparison, not a plan.

The spread from cheapest to dearest is a factor of 100. The spread among models a careful builder would pick for judgment work (Opus, Sonnet, gpt-6.1-sol, the Gemini pro tier) is about a factor of 2. Either way the top of the range is around $5,000, and as Part B shows, that's less than the books.

Part B: getting the books#

Buying#

The short post used $15 to $30 a book. That's my assumption for a mix of new hardcovers, paperbacks and used copies of out-of-print books; I didn't find a dataset of what Greene's sources cost. Some 1930s books he likes will be cheap used copies. Some will be rare and expensive. Some won't be findable at all.

At the base case, the books ($9,000) cost 13 times the realistic model mix ($686) and about four times the all-Opus list price ($2,033).

Public-domain books are free. The research notes point to Internet Archive full text with page-level hOCR for pre-1929 sources. For a Greene book that covers ancient history through the twentieth century, some fraction of the reading list will be free this way. I didn't estimate the fraction.

Scanning#

The pipeline needs every page as text with its printed page number, so that each card can point to a page. That means scanning and OCR. Pages per book is my assumption: 350 pages, about 286 words a page for a 100,000-word book.

OCR prices, from this report's tools research (vendor pages read on 2026-11-11 unless marked):

Sources: Datalab pricing, Mistral OCR 3, olmOCR. The olmOCR figure excludes the machine you run it on.

Price isn't the only axis. On the olmOCR benchmark's "old scans" column, which matters most for out-of-print books, the tools research records Chandra at 50.4, olmOCR 47.7, Marker 33.5 and the Mistral OCR API 29.3. The cheapest option that's also good on old print is olmOCR on your own hardware. The difference between the cheapest and the dearest hosted option for 400 books is about $1,300, still small next to the books.

Scanning as a service. The Internet Archive's Scribe stations are the best-documented route. The research notes record about 450 to 500 pages an hour per operator (IA blog, 2015) and partner prices quoted secondhand at $0.10 a page, or $3 a book plus $0.10 a page, with one university reported to have paid between $0.10 and $2 a page. These are old, secondhand figures. I include them as an order of magnitude.

At $0.10 a page, outsourcing the scanning costs more than buying the books. At $2 a page it costs more than everything else in this chapter combined.

Scanning it yourself#

Two routes, from the tools research:

• Destructive. Cut the spine, feed the pages through a sheet-fed duplex scanner. This is what the Bartz record describes Anthropic doing with millions of bought books. A ScanSnap iX1600 is rated at "40 ppm/80 ipm (A4-size documents, color, 300dpi)" with a 50-sheet feeder.
• Non-destructive. A V-shaped cradle with two cameras (the DIY Book Scanner design) or an overhead scanner. Slower, but keeps the book, which matters for rare copies.

Human time, with my assumptions marked:

The 10 minutes per book is a guess. A 350-page book at 50 sheets per load is four loads of 100 pages each, plus cutting the spine and checking for misfeeds. The sensitivity section tries 5 and 20 minutes.

Ninety-six hours is more than two working weeks. That's the cost the short post didn't count.

Part C: the human hours#

Greene's baseline#

Greene's numbers, as he gives them in interviews and written sources:

The 2015 recap also says "the actual writing is only about one-third of the process." If that's right, a writing day of 3 hours sits inside a working day of about 9. Converting to hours is rough, so here it is as a range, with every step labelled:

A book-listing site claims "more than 20,000 hours of research and thought" went into Mastery (1000kitap), which is above my high end. I wouldn't lean on it. The useful conclusion is the order of magnitude: Greene spends somewhere around ten thousand hours on a book.

Carding by hand#

If the agents read and mark but a human writes the cards, as Holiday did for himself, the cost is Holiday's rate. He says transferring a big book's extracts "might take two or three days of work". At the LA event a book worth 60 cards takes "like 4 days" of copying. Not every book is big. My split:

That's more than a working year, before any writing. It's the job the pipeline gives to the carder for $19.20, and the job that, by Greene's and Holiday's accounts, is where they get to know the material (Craft, shortcuts and other writers has the argument).

Checking the facts#

This is the stage that doesn't get cheaper. My estimate, with every assumption shown:

At the base: 3,000 × 2 min = 100 hours, plus 300 flagged × 15 min = 75 hours. About 175 hours. That's close to the short post's 200 stories at an hour each.

Without page anchors it's much worse. If each claim takes 12 minutes to trace back to a source because the sentence doesn't say where it came from, 3,000 claims take 600 hours. Card IDs that resolve to a page are what turn 600 hours into 175.

Why the flag share matters: the verification chapter covers the error rates in detail, but for scale, a 2026 study found 3% to 13% of citation URLs in deep-research reports were hallucinated (Rao et al.), and in DeepTRACE the best product left 12.5% of statements unsupported by its own citations (DeepTRACE). If 1,000 of the claims carry a citation, that's 30 to 130 bad ones. A 10% flag rate is in the same range as those failure rates. 30% would be a pipeline whose checker is nervous or whose drafts are poor.

The gates#

The pipeline keeps three human gates and a final read. Times are my assumptions:

Gate 3 is where Greene says the work is: "Finding those stories is extremely elemental." An hour per candidate is generous for a summary and thin for reading the source. The sensitivity section tries half an hour and three hours.

All the human time#

446 hours is about 11 weeks of full-time work, against Greene's six to eighteen thousand. That's the real saving, and it's large. It's also not zero, and it's where the money is.

To put hours in dollars I need a rate. I don't have a sourced one for this work, so I use $50 an hour as an illustrative base and test $30 and $100. At $50, 446 hours is $22,292.

Part D: the legal benchmark#

The cost of a book you buy is its price. The cost of a book you pirate is set by law and, in practice, by the largest settlement so far. In Bartz v. Anthropic, Judge Alsup ruled in June 2025 that buying print books and scanning them was fair use and that building a library from pirated copies was not. The case settled for $1.5 billion covering about 482,460 works, about $3,000 a work, four times the $750 statutory minimum (Authors Guild). Final approval came in July 2026.

The settlement rate is about 133 times the purchase price. The research notes are careful about what this means for one researcher: reading books you bought is not the legal issue; building a shared or distributed corpus from pirated copies is. So $3,000 is a liability benchmark, not a cost. It answers a narrow question: how much does skipping the purchase save? About $9,000, against an exposure 133 times larger. The dark machine chapter looks at who might take that bet anyway, and why.

Part E: the whole bill for one book#

Human time is about 69% of the base total. Books are 28%. Models are 2%. OCR is 1%.

Sensitivity#

Model cost only#

Starting from the realistic mix at $686, each row moves one assumption and holds the rest:

The draft loop dominates, so the assumptions that touch it (how many drafts, how much the model thinks, how often calls fail) move the bill most. The tokenizer uncertainty, which looks alarming in the abstract, moves it by about $136, because the expensive tokens are re-read card context, not the books.

Even the worst row stays under $1,500. Combining the bad cases (40 drafts, 3× thinking, 50% retries) pushes the mix to $3,874, still well under the cost of the books.

Everything#

Starting from the full base of $32,398, sorted by how much each assumption moves the total:

The top five rows are all about human time spent checking and choosing. The next three are about books. Model assumptions start at row ten. The single number that most changes the cost of an AI-made Greene book is what you pay the person who checks it.

Part F: scale#

What happens if one operator makes more books? Per-book figures are the base case, with no sharing of books between projects.

Everything in that table grows in a straight line, because it was built that way. In practice the lines bend differently.

What grows linearly.

• Fact-checking. Every book has its own claims. 175 hours a book is 175,000 hours at 1,000 books, about 88 people doing nothing else. Nothing about scale makes one claim faster to check. If anything it gets harder, because the checker has seen the same sources less often.
• Gates. Picking the story for a chapter can't be shared across books. 145 hours of gates a book (Gate 1, 2 and 3) is 145,000 hours at 1,000.
• Model tokens. Per book, roughly. Volume discounts exist in the market but I have no published figures for them.

What grows less than linearly.

• Books, if topics overlap. A biography of Napoleon serves a war book, a power book and a book on ambition. An operator writing many books in one field would buy each source once. If three-quarters of each reading list were already on the shelf (an illustration, not a measured figure), the 1,000-book line would buy about $2.25 million of books instead of $9 million. Anthropic's Project Panama, which bought "millions" of used books and scanned them, is this logic at its limit.
• Scanning. Same as books: you scan each one once.
• OCR. At 1,000 books and no reuse, 140 million pages. Self-hosted olmOCR at under $200 per million pages is under $28,000. Datalab Balanced is $420,000. At that volume, running your own OCR is the obvious choice.

What doesn't grow at all.

• The pipeline. The prompts, schemas, card checker and Vale style are written once.
• Hardware. A scanner and a GPU for OCR are bought once and used until they wear out. I didn't price them.

What caps it. Amazon limits self-publishers to three new titles a day per account (Authors Guild), which is 1,095 a year. So 1,000 books a year fits under one account's limit. The bottleneck isn't the platform.

The scale table makes the point the short post made in a sentence. At 1,000 books a year the model bill is under $700,000 and the human bill, at $50 an hour, is about $22 million. An operator who wants the model bill to dominate has to cut the humans. Cutting the humans means cutting the fact check and the story choice, the two things this report has argued a Greene book can't do without. That's the cheap version, and it's what the dark machine chapter is about.

Three ways to run it#

The base case assumes the full machine: agents draft, humans check and choose. The short post ended on a different version, where the model does Ryan Holiday's old job and a person still writes. The two have very different bills, and a third version, with no humans at all, is the one to worry about. Here they are side by side for one book.

A. The agents as research assistant#

The model reads, marks, re-reads, proposes cards and candidate stories, and runs the critics on drafts a human writes. It doesn't draft. Per chapter and draft, the critics are three calls (fact checker, bored reader, voice critic) sharing the same 181,333-token prefix, plus the repetition critic on the whole book.

The human time is the base 446 hours plus the writing. Using the writing-hours range from Greene's baseline (2,000 to 6,000), that's 2,446 to 6,446 hours. If the human also writes the cards by hand at Holiday's rate (2,600 hours), it's 5,046 to 9,046.

At $50 an hour that's $122,300 to $452,300 of human time, against about $500 of models. In this version the model bill is a tenth of a percent. The saving against Greene is still real: he spends about 6,000 to 18,000 hours, and this version cuts the reading and most of the checking. But it's a saving of months, not years, and it leaves the person doing the part Greene says is the work.

B. The full machine with human gates#

This is the base case: $686 of models, $9,000 of books, $420 of OCR and 446 hours. About $32,400 at $50 an hour. It's the cheapest version that still checks every fact and has a person choose every story.

C. No humans#

Drop the gates, the fact check and the final reads. Pirate the books instead of buying and scanning them. What's left is the model bill, about $686, and someone to start the run.

Version C costs about 2% of version B. Everything that makes it cheaper is something this report has argued a Greene book needs: bought sources with page anchors, a human check of every fact, a human choice of every story. That's why the cheap version is a threat model, not a business plan, and why it gets its own chapter (The dark machine).

What this model leaves out#

A cost model is only as good as its list of omissions. These are the ones I know about.

Building the pipeline. Prompts, schemas, the card checker, the page-number reader, the Vale style and the glue between the tools in the tools chapter all take engineering time. That's a fixed cost, paid once and spread over every book, and I have no basis for a number. For one book it could easily exceed everything else here. For a thousand it rounds to nothing.

Failures. The retry row in the sensitivity table covers calls that fail and run again. It doesn't cover a stage that produces bad output nobody notices until later, which means re-running everything downstream. A bad architect pass, caught at Gate 2, costs one more architect pass. A bad card set caught at the fact check costs a second carder run and a second set of drafts. The draft loop is the expensive part, so a late catch can double the model bill. It still wouldn't approach the cost of the books.

Checking the OCR. The card checker compares each quote to the OCR text. If the OCR is wrong, a correct quote fails and a human has to look at the page image. The tools research found that the printed page number isn't the PDF page number, and that no benchmark measures reading it. On a 1930s book with poor print, the error rate could be high enough to add hours to the fact check. I haven't estimated it.

Books that can't be bought. Greene likes books "that no one has heard of that were published in 1930, that are completely out of print." Some won't be available at any price. The model treats every book as purchasable at $15 to $30. A reading list built around rarities will cost more, take longer to assemble, and be smaller than planned.

Storage and compute for self-hosting. olmOCR's "under $200 per million pages" is the running cost, not the GPU. I didn't price hardware.

Interviews. Greene interviewed nine contemporary masters for Mastery, and Caro interviews people ten or twenty times (see the previous chapter). Transcribing an interview is cheap; the tools research has WhisperX for that. Arranging, conducting and following up on it is human time this model doesn't include, because the base case is a book built from reading.

Permissions. A Greene book quotes his sources. Quoting short passages for commentary is common practice, but some publishers ask for permissions on longer extracts. I found no data on what that costs for a book like this and left it out.

Calendar time. Hours are not weeks. Batch jobs are asynchronous. Books arrive in the post. A person doing 446 hours of gates and checks at 40 hours a week takes about 11 weeks, and gates have to happen in order: the outline can't be signed off until the cards exist, and the stories can't be picked until the outline is fixed. My guess is that a careful version B takes several months of calendar time. That's still a large change from Greene's three to seven years.

Checking the short post against this chapter#

The short post gave five numbers. Here's how each holds up.

The headline survives: the machine part is under a few thousand dollars, and the books and the checking cost more. The draft loop is the line the short post got wrong, by about a factor of seven at cached Opus prices. That changes nothing about the conclusion, because even the corrected figure is under a tenth of the books.

What the numbers say#

1. The model cost is a rounding error. A realistic mix of Claude models costs about $700 for a Greene-scale book, about $2,000 if everything runs on Opus at list price. That's 2% to 6% of the base total.
2. Within the model bill, rewriting costs more than reading. Reading 400 books twice and turning them into 10,000 cards costs about $93 in the mix. Twenty drafts with critics cost about $543, because each draft re-reads its chapter's cards. The number of drafts and how much the model thinks matter far more than the tokenizer.
3. Books cost more than models. Buying 400 books at $15 to $30 is $6,000 to $12,000. Paying someone to scan them can cost more than buying them.
4. Human time costs the most, and most of it is checking. About 450 hours a book under my assumptions, of which 175 are fact-checking and 75 are choosing stories. Every one of the top five sensitivity rows is about that time.
5. Page anchors are the biggest saving available. A claim that points to its card and page takes about 2 minutes to check. One that doesn't takes about 12. Over 3,000 claims that's 175 hours against 600.
6. At scale, verification is the cost that doesn't bend. Books and scanning can be shared across projects. Pipelines are written once. Each book's facts have to be checked on their own.

Sources#