I Sent 1.39 Million Tokens to GPT 6 Luna. The Bill Was a Few Cents.

Three reads of a 157-file repository, three finished documents, and a total of $0.284. GPT-6 Luna's 1M-token context and $0.10-per-million input price make a workflow I used to think was wasteful, sending the whole codebase in one prompt, cheaper than the retrieval layer I used to build to avoid it. The video shows the run. This post has the per-document bill, the long-context rate that applied to all of it, and where I still use a bigger model.

The model

GPT-6 Luna is the low-cost member of OpenAI's GPT-6 line, released September 22, 2026 and positioned below GPT-6 Sol. It is a hosted model: you call it through an API and the weights stay with OpenAI. GMI serves it at OpenAI's list price.

The second price row is the one this post is about. Every prompt over 272K input tokens bills at twice the input rate and 1.5 times the output rate. A whole-repository prompt is over that line by design, so the headline $0.10 never applied to this run. The number that did apply is still small enough to change how I budget for context.

Two numbers that matter here

OpenAI's claim for the first row is that Luna at max effort lands where Claude Opus 5 and Fable 5 land at medium effort, at 93% less per task than Opus 5 and 96% less than Fable 5. That is the lab's own comparison and its own choice of effort levels, so read it as a price claim with a benchmark attached rather than the other way round.

The second row is independent. Artificial Analysis scores Luna at 38 on its index at max effort, 30 at medium, and measures about 139 output tokens per second. It also measures roughly 100 seconds to the first token at max effort, because the model reasons at length before answering. For a documentation chain that runs unattended, that latency is fine. For anything interactive, drop the effort setting.

One number from the video I am leaving out here: the long-context reasoning score. I could not re-confirm the figure on the public leaderboard as of October 11, so the benchmark case in this post rests on the two rows above and on the run itself.

What I built

Repo Digest is a five-step chain on one page. Paste a GitHub URL, pick a context budget, and the server downloads the repository as a tarball, ranks the files (README, docs and config first, source next, tests last) and packs them into one prompt up to the budget. Luna then writes three documents in sequence: an architecture guide with a system diagram, a changelog that opens with a timeline table of real commits, and an onboarding guide that receives the finished architecture document as part of its prompt. Each document re-sends the whole repository, so a 500K run is three prompts of roughly 500K tokens. A metrics column tracks cost, tokens, speed and latency as it runs, built from the usage data the API returns.

The input in the video was thedotmack/claude-mem, a trending repository with about 96,000 stars, at a 500K-token budget.

The per-document cost is the useful unit. A full read of a 157-file repository and a finished document came to nine and a half cents, three times in a row, with the variance in the third decimal place.

What the documents contained is the part I would not have predicted a year ago. The changelog's timeline rows carried the real commit hashes and dates and tied commit messages to the specific functions that changed, which is the difference between a changelog and a reformatted git log. The onboarding guide listed the two runtimes the project actually has, named the exact Node version the repository requires, and gave the commands to get there. The architecture guide opened with a system diagram and a top-level directory map, then the main runtime flow and the key abstractions with the files that define them. None of that came from retrieval; the whole repository was in the prompt.

The long-context rate, in practice

All three prompts were over 272K tokens, so the whole run billed at $0.20 per million input and $0.75 per million output. The arithmetic checks: 463K input tokens at $0.20 is $0.093, plus 2.8K output tokens at $0.75 is $0.002, which is the $0.095 the architecture step reported.

Two things follow. The 272K line is worth designing around: a 250K budget would read about half of this repository at half the per-token price, and Repo Digest exposes the budget as a control for exactly that reason. And the generational drop is larger than the tier penalty. Even at the surcharged rate, the same chain on the previous Luna would have cost ten times as much. That ratio, not the headline price, is what changed how I approach documentation work.

What held up, and when I still reach for a bigger model

For years I treated context as scarce: split files into chunks, build a retrieval layer, decide which twenty files the model is allowed to see. When sending the entire repository costs a few cents, the best retrieval strategy for a read-heavy job is often to skip retrieval and send the repository. The documents in this run named modules from the source tree, commands from the project's own configuration, and hashes from its history. Until now I associated that level of repository-wide grounding with models that cost ten to twenty times more.

The limit is the other direction of work. When I am debugging subtle logic across a broad change, I still reach for a larger model. Luna's agentic coding scores sit well below its larger siblings: Artificial Analysis puts it at 41 on its Coding Index, two points under the previous Luna. Reading a repository and writing about it is not the same job as changing it.

So the routing rule is simple. Documentation, audits, onboarding guides, migration planning, changelogs, and anything else heavy on reading and light on writing: Luna, with the whole repository in the prompt. Multi-file edits where the model has to be right about code it is changing: something bigger, and the retrieval layer stays.

Try it on GMI Cloud

The whole chain is three ordinary chat completions with very large user messages.

Watch usage.prompt_tokens in the response. Over 272,000 and the request bills at the long-context rate shown above; under it, at the standard rate. Stream the response, since a half-million-token prompt takes tens of seconds before the first token. Repo Digest's budget control exists so you can pick which side of that line a run lands on.

The question to answer

Which retrieval layer in your stack exists only because context used to be expensive? Pick one repository you actively maintain, send the whole thing to Luna with the prompt above, and read the bill next to the document. If the document is usable and the bill is cents, that layer has a replacement.

Ready to build? Get Started