A capable open model finally fits on a $2,000 GPU. OpenAI's price cut moved the payoff line the other way.

Meta released Muse Glimmer on August 10, a 30 billion parameter open-weight model built to run on a single consumer GPU instead of a data center.¹ That is a genuine first for the classification, extraction, and log-analysis work SEO and data consultants actually run. In the same fortnight, OpenAI cut its cheapest API model 80% and DeepSeek put a 304 billion parameter open-weight model on Hugging Face.²⁵ Those three events raise one question: does any of this change whether you should run a model yourself instead of calling an API? The honest answer is an arithmetic problem, and it moved against buying hardware in the same two weeks that made buying hardware look newly plausible.

OpenAI’s July 30 price cut alone moved the hardware break-even point on a representative classification task from about 1.8 million calls to about 9.1 million, roughly five times higher, while local models got no cheaper to run in the meantime.³⁴

What changed for local models in the last two weeks?

Three verifiable events reset the calculus around running a model on your own machine inside twelve days. On July 30, OpenAI cut gpt-5.6-luna’s price 80% and gpt-5.6-terra’s 20%.² A day later, DeepSeek released DeepSeek-V4-Flash-0731, a 304 billion parameter open-weight model, on Hugging Face.⁵ Ten days after that, Meta shipped Muse Glimmer under an Apache 2.0 license. The order matters. The API got radically cheaper before a genuinely local-capable model even arrived.

What does Muse Glimmer actually need to run on your own machine?

Muse Glimmer needs a GPU with 24 to 32 gigabytes of memory, according to Meta’s own release notes. At full precision, its 30 billion parameters would need more than 55 gigabytes, more than any consumer card carries.¹ So Meta compressed the weights to roughly 4-bit precision, a method that stores each number in about a quarter its original space. That shrank the model itself to under 20 gigabytes.¹ The saved room fits in that 24 to 32 gigabyte range alongside working memory, an image-understanding module, and a smaller draft model that speeds up generation. Meta tested the result on a MacBook with an M4 Max or M5 Max chip and on an RTX 5090 desktop card, which carries a $1,999 launch price and 32 gigabytes of memory of its own.¹⁶⁷

Why doesn’t DeepSeek’s 304 billion parameter model belong in this conversation?

DeepSeek’s 304 billion parameter model needs enterprise hardware no solo consultant owns. Its own model card recommends serving DeepSeek-V4-Flash-0731 across four Nvidia GB300 accelerators in a single server node, a configuration priced and sized for a data center, not a desk.⁵ Released under an MIT license, with all 304 billion parameters public on Hugging Face, the model is genuinely open-weight, and that openness is real. Open-weight and locally runnable are two different claims, though, and DeepSeek’s release satisfies only the first.

Meta AI Research release notes (Aug 10, 2026) and the DeepSeek-V4-Flash-0731 model card on Hugging Face, both checked 2026-08-12.

Does the arithmetic favor buying hardware or paying per token?

For most SEO and data pipeline volumes, paying per token still wins, by a wider margin than it did three weeks ago. Take an illustrative call shaped like a product title classification task: roughly 500 input tokens for the title, a short description, and a category list, and 100 output tokens for a label and a one-line reason. That representative call cost $0.0011 before OpenAI’s cut and now costs $0.00022.

Before OpenAI’s cut, gpt-5.6-luna’s launch pricing of $1.00 per million input tokens and $6.00 per million output tokens put that call at $0.0011.³ Against a $1,999 GPU, the hardware would have paid for itself at around 1.8 million calls. After the cut, luna prices at $0.20 per million input tokens and $1.20 per million output tokens, verified live against OpenAI’s own pricing page on the day this ran.⁴ The same call now costs $0.00022, and the same GPU does not pay for itself until around 9.1 million calls.

Batch processing pushes the API side further ahead rather than closing the gap. For work that can wait a few hours, OpenAI’s Batch API prices the same luna calls at $0.10 per million input tokens and $0.60 per million output tokens, half the standard rate.⁴ That halves the per-call cost again, which raises the break-even volume to roughly 18.2 million calls rather than lowering it. Running a few thousand to a few hundred thousand items through a pipeline in a month, which covers most title-tagging, feed-classification, and log-analysis work, a solo practitioner never gets near the volume where a dedicated GPU purchase pays for itself on price alone.

When does local win before you even run the numbers?

Local wins before any price math runs when the hardware is already paid for, the data cannot leave the machine, or the work has to run without a connection. If you already own a GPU or a Mac in Muse Glimmer’s memory range, for gaming, video, or other work, the marginal cost of running it locally sits close to zero regardless of whether the break-even sits at 1.8 million calls or 9.1 million, because there is no new purchase to amortize (spread its cost over time). Client data that cannot transit a third-party API is a harder constraint than any price comparison, and it settles the decision before volume enters the picture at all. A missing connection carries the same weight, since it removes the API from the choice entirely rather than just making it pricier.

Where does local lose outright, regardless of price?

Local loses outright on long-context work (tasks that need holding a lot of text in memory at once), the hardest reasoning tasks, and anything that needs a guaranteed output shape. Muse Glimmer’s release notes describe it as tuned for agentic tasks such as tool calling and coding, not as a long-context or frontier-reasoning model, and nothing in Meta’s materials claims parity with a frontier API model on either front.¹ Labeled as my own synthesis rather than a claim Meta makes, a hosted API built around strict, schema-validated output is a more reliable way to guarantee a parseable result at scale than a locally served open-weight model, where the output contract depends on whichever inference stack you bolted on yourself. A misclassified product title from a broken local JSON parse costs more than the tokens saved by skipping the API call.

How do you find your own break-even point?

Multiply your average input tokens per item by $0.0000002 and your average output tokens per item by $0.0000012, the current per-token rates for gpt-5.6-luna, add the two figures, then divide the price of hardware you would need to buy by that per-item cost.⁴ The result is the volume at which local hardware breaks even against the API, for your own workload rather than the 500-in, 100-out classification call this piece uses as its example, whose own break-even sits at about 9.1 million calls. When your realistic monthly volume sits well below that number and the hardware would be a new purchase, the API stays the cheaper choice even with a capable open model sitting on Hugging Face waiting to be downloaded.

That formula, like the break-even arithmetic earlier in this piece, omits four real costs. One is electricity. The RTX 5090 draws up to 575 watts under load, and running it for millions of calls is not free power. Another is GPU depreciation and resale: a card bought today will not be worth $1,999 in two years, and selling it used recovers only part of the price. A third is your own setup and maintenance time, since getting an inference stack running and keeping it running costs hours somebody has to value. The fourth is the sharpest: both prices, what the API charges and what you paid for the GPU, are assumed to hold still for as long as the break-even takes to arrive. This article’s own news peg is two price moves in twelve days.

Does the sub-agent crossover move at the new prices too?

Not the way the hardware break-even did. An earlier piece on this site argues that past roughly a few hundred identical items, calling an API directly beats spawning one sub-agent per item, and names the binding constraint as the orchestrating session’s own context window filling with returned summaries, not the per-token price. That piece states plainly that the number is a heuristic rather than a measured threshold, and it gives no per-item token count and no sub-agent overhead figure to rerun.

Those two inputs cannot be recovered from that article or from anything else on this site, so what follows is a worked method, not a corrected number, with every input labeled as what it is.

Start from the same representative call: 500 input tokens and 100 output tokens, a title-classification task. A direct loop over luna at today’s price costs $0.00022 per item, so 1,000 items cost $0.22. A sub-agent adds the delegation message plus the summary handed back to the orchestrator. Assume, as a stated estimate rather than a measured figure, that one sub-agent invocation runs about four times the token volume of a direct call. On that assumption a sub-agent costs roughly $0.00088 per item, or $0.88 per 1,000 items, and the gap holds at any volume, since neither side carries a fixed cost to spread across it.

That is the real finding. The hardware break-even earlier in this piece has a crossover because a GPU is a fixed cost, amortized over volume. The sub-agent comparison has no fixed cost on either side. If sub-agents cost more per item, they cost more at every volume, not only above some threshold. The rough figure in the original piece was never a price crossover, and recomputing it at today’s prices does not move it. It confirms what that piece already argued: the reason to pick a sub-agent over a direct loop is convenience and the orchestrator’s own context budget, not price, and no price cut changes that.

None of this makes Muse Glimmer or DeepSeek’s release less real. Three weeks ago, a genuinely capable, locally runnable model on consumer hardware did not exist; now one does.¹ What changed at the same time is the thing that decides whether that capability is worth paying for: the API got cheaper faster than the case for owning hardware got stronger. For an earlier piece on Anthropic’s J-space research, I ran a Gemma 3 12B model through Neuronpedia’s hosted infrastructure, measuring what the model could do rather than what running it would cost. This piece runs the cost side of that same question instead. On a different axis sits the agent cost curve Claude Sonnet 5 set, which compares one API model’s price against another rather than against owned hardware, and the shape here borrows from the roughly-500-item crossover that decides when a sub-agent stops being the convenient choice. This one just puts a GPU on the other side of the ledger instead of a second API call.