OpenAI cut Luna’s price by 80%. One day later, open weights moved the floor again.
Useful intelligence is moving from a scarce product to a widely available utility
On July 30, OpenAI cut the price of GPT-5.6 Luna by roughly 80%. Input dropped from $1 to $0.20 per million tokens, and output from $6 to $1.20.
I looked at where Luna fit in my stack. At those prices, I could use near-frontier intelligence for routine work without thinking about the cost of every call. I expected to use Luna much more often.
On July 31, DeepSeek released V4 Flash 0731.
I tried it and moved the cheapest layer of my stack to V4 Flash within a few hours. OpenAI’s cut was still substantial, but it had already stopped looking like the new price floor.
The announcement that lasted one day
DeepSeek V4 Flash 0731 costs $0.14 per million input tokens and $0.28 per million output tokens. Cached input is $0.0028 per million tokens. Luna’s input price is close after the cut, but its output still costs more than four times as much.
Those numbers would be less interesting if V4 Flash were limited to autocomplete and summaries. Independent evaluations currently place it in roughly the same capability band as GPT-5.6 Luna and GLM 5.2.
Its architecture explains some of the economics. V4 Flash has 284 billion parameters in total, but activates only around 13 billion for each token. That sparse activation cuts the amount of computation required for each request.
It also has a one-million-token context window, reasoning, tool calling and an OpenAI-compatible API. DeepSeek released the weights under an MIT license.
GPT-5.6 Sol remains considerably stronger on the hardest tasks, while Luna is fast, multimodal and supported by a mature production platform. I would still choose either of them when those advantages matter. For ordinary work, V4 Flash is close enough that the price difference becomes difficult to ignore.
The frontier still wins on absolute capability, but V4 Flash changes what everyday intelligence costs
It changed my actual stack
I use GPT-5.6 Sol at the top of my stack, where getting the best result matters more than token cost. For everyday work, I use Grok 4.5.
The lowest-cost layer used to alternate between DeepSeek V4 Pro and GLM 5.2. It handles routine coding, transformations, classification, background agents and the repeated calls inside larger workflows. V4 Flash replaced that layer almost immediately. That swap tells me more than any benchmark would.
At this point I see little reason to stay loyal to one provider. I reserve Sol for the small set of tasks where “best” really matters, use a fast daily driver for interactive work, and route high-volume jobs to the model with the best price-performance tradeoff at the time.
V4 Flash pushes the same curve much further. The cheaper models I used to run were small and experimental; V4 Flash is capable enough to sit behind production workloads.
This did not begin with DeepSeek
A few weeks earlier, Moonshot released Kimi K3, a 2.8-trillion-parameter model with 104 billion active during inference. It reached the same broad performance territory as some of the strongest proprietary models.
Kimi used enormous scale to approach the frontier. DeepSeek accepted slightly lower capability and drove down the cost. GLM, Qwen and other model families keep filling the space between them with different balances of capability, context length and hardware efficiency.
Open-weight labs are no longer chasing proprietary models along a single benchmark curve. They can compete on whichever constraint matters to a user, including price.
A week before DeepSeek’s release, the open-weight movement was already gaining political momentum. On July 24, 25 organizations signed the Open Weights and American AI Leadership letter. The initial signatories included NVIDIA, Microsoft, Meta, and Hugging Face. By July 30, more than 230 companies and organizations had joined, among them Google, OpenAI, GitHub, and Amazon. Anthropic remained absent.
Its economic argument is straightforward. If the strongest models remain behind a handful of APIs, every company has to rent intelligence from the same small group of providers. Open weights let organizations run and adapt models themselves, avoid provider lock-in, choose their own infrastructure and reserve expensive frontier APIs for the few problems that genuinely need them.
The letter asks policymakers to support that ecosystem by expanding access to compute, investing in shared training resources and avoiding premature restrictions on open models. Its safety argument is more contested. Anthropic agrees with the economic benefits, but argues that whether open weights help defenders more than attackers should be tested rather than assumed.
Kimi K3, the American open-weights coalition, OpenAI’s Luna price cut and DeepSeek V4 Flash
Open weights are not open source
The industry routinely calls downloadable models open source. That label promises more than most releases provide. Open weights and open source are not interchangeable.
With open-source software, you receive the source code used to build the program. You can inspect the logic, trace changes and reproduce the binary. The source is the preferred form for understanding and modifying the system.
Model weights are the result of training. They do not describe the complete process that produced them.
A typical release includes the architecture, weights, inference code, a model card and perhaps a technical report. All of that is useful, but it rarely includes the full training data and its provenance, the filtering and labeling pipeline, intermediate checkpoints, or enough detail to reproduce the post-training process.
The Open Source AI Definition requires substantially more than downloadable weights. It includes the code and sufficiently detailed data information needed for a skilled person to build an equivalent system.
Open weights still give us meaningful control. We can deploy the model ourselves, inspect its activations, modify its behaviour and fine-tune it without asking a vendor for permission. What we usually cannot do is audit the model’s complete history.
The weights expose the artifact, not necessarily the recipe.
Open weights expose the artifact; open source also exposes the process that produced it
The trust problem moved
The missing training history becomes a security problem when a model contains behaviour that ordinary testing never triggers.
A joint study from Anthropic, the UK AI Security Institute and the Alan Turing Institute found that as few as 250 poisoned documents could install a simple backdoor during pretraining across models ranging from 600 million to 13 billion parameters.
The poisoned models behaved normally until they encountered a specific trigger. In the paper’s fine-tuning experiments, a model could refuse harmful requests during normal use but comply when a hidden suffix appeared. Adding far more clean training data did not erase the effect of the poisoned examples.
In a demonstration by Akash Mukherje, a similar backdoor was installed in a Llama model using roughly 500 poisoned conversations. It achieved a greater than 95% attack-success rate when the trigger appeared, while remaining safe during ordinary tests.
What bothered me was how little any of this changed the model’s normal appearance. A poisoned checkpoint can still perform well, pass standard benchmarks and look aligned because nobody happened to test its trigger.
None of this is evidence that DeepSeek V4 Flash, Kimi K3 or another named release contains a backdoor. It shows what a weights-only release cannot prove: that the published checkpoint was trained exactly as described and contains no hidden conditional behaviour.
Closed APIs do not solve the problem. A proprietary model could contain the same behaviour, with fewer options for an outsider to investigate it. The demonstration’s white-box analysis of internal refusal signals was possible because the researchers could inspect the model.
Open weights improve observability without establishing provenance.
I keep returning to the same lesson I found while thinking about AI-agent skills as untrusted code: the label is not the contract. The behaviour is.
Running a model on my own infrastructure removes the API provider from the path. I still have to trust whoever produced the checkpoint.
Abundant intelligence
Frontier training remains enormously expensive, and “local” does not mean Kimi K3 will run on a MacBook. Many of these checkpoints still need serious multi-GPU infrastructure. What has become cheap is access to useful inference.
Most software works perfectly well with a model that is capable enough, repeatable and cheap enough that a developer does not ration every call. At V4 Flash prices, a background process can classify the full dataset instead of a sample, and a product can try a hundred model calls where five used to exhaust the budget.
OpenAI’s Luna cut showed how quickly inference prices were falling. DeepSeek’s release one day later showed that no provider gets to hold that floor for long.
I do not know which model will occupy the cheapest layer of my stack a month from now. I am increasingly sure it will not stay there for long. Useful intelligence is becoming abundant faster than our ability to establish where it came from and whether we should trust it.
Sources and further reading
- DeepSeek, DeepSeek V4 Flash 0731 model card
- Moonshot AI, Kimi K3 technical report
- Open Weights and American AI Leadership
- Open Source Initiative, Open Source AI Definition
- Anthropic, UK AI Security Institute and the Alan Turing Institute, A small number of samples can poison LLMs of any size
- Akash Mukherje, The Hidden Risk Inside Open-Weight Models
I work mostly on securing coding agents and the tooling that runs alongside them. If you are working on this too, I would genuinely like to compare notes.